mirror of
https://github.com/panda3d/panda3d.git
synced 2025-10-03 02:15:43 -04:00
Properly separate dtoolconfig and interrogatedb
This commit is contained in:
rdb
parent
c0f6588c88
commit
dd17fd864b
@ -2475,20 +2475,22 @@ static PyMethodDef python_simple_funcs[] = {
|
||||
#if PY_MAJOR_VERSION >= 3
|
||||
static struct PyModuleDef python_simple_module = {
|
||||
PyModuleDef_HEAD_INIT,
|
||||
"dtoolconfig",
|
||||
"interrogatedb",
|
||||
NULL,
|
||||
-1,
|
||||
python_simple_funcs,
|
||||
NULL, NULL, NULL, NULL
|
||||
};
|
||||
|
||||
#define INIT_FUNC PyObject *PyInit_dtoolconfig
|
||||
#define INIT_FUNC PyObject *PyInit_interrogatedb
|
||||
#else
|
||||
#define INIT_FUNC void initdtoolconfig
|
||||
#define INIT_FUNC void initinterrogatedb
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
extern "C" __declspec(dllexport) INIT_FUNC();
|
||||
#elif __GNUC__ >= 4
|
||||
extern "C" __attribute__((visibility("default"))) INIT_FUNC();
|
||||
#else
|
||||
extern "C" INIT_FUNC();
|
||||
#endif
|
||||
@ -2497,7 +2499,6 @@ INIT_FUNC() {
|
||||
#if PY_MAJOR_VERSION >= 3
|
||||
return PyModule_Create(&python_simple_module);
|
||||
#else
|
||||
Py_InitModule("dtoolconfig", python_simple_funcs);
|
||||
Py_InitModule("interrogatedb", python_simple_funcs);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
@ -86,6 +86,14 @@
|
||||
#define EXPTP_DTOOLCONFIG IMPORT_TEMPL
|
||||
#endif
|
||||
|
||||
#ifdef BUILDING_INTERROGATEDB
|
||||
#define EXPCL_INTERROGATEDB EXPORT_CLASS
|
||||
#define EXPTP_INTERROGATEDB EXPORT_TEMPL
|
||||
#else
|
||||
#define EXPCL_INTERROGATEDB IMPORT_CLASS
|
||||
#define EXPTP_INTERROGATEDB IMPORT_TEMPL
|
||||
#endif
|
||||
|
||||
#ifdef BUILDING_MISC
|
||||
#define EXPCL_MISC EXPORT_CLASS
|
||||
#define EXPTP_MISC EXPORT_TEMPL
|
||||
|
||||
@ -8,5 +8,6 @@
|
||||
#include "stringDecoder.cxx"
|
||||
#include "textEncoder.cxx"
|
||||
#include "unicodeLatinMap.cxx"
|
||||
#include "vector_int.cxx"
|
||||
#include "vector_string.cxx"
|
||||
#include "win32ArgParser.cxx"
|
||||
|
||||
@ -14,8 +14,8 @@
|
||||
|
||||
#include "vector_int.h"
|
||||
|
||||
#define EXPCL EXPCL_DTOOLCONFIG
|
||||
#define EXPTP EXPTP_DTOOLCONFIG
|
||||
#define EXPCL EXPCL_DTOOL
|
||||
#define EXPTP EXPTP_DTOOL
|
||||
#define TYPE int
|
||||
#define NAME vector_int
|
||||
|
||||
@ -26,8 +26,8 @@
|
||||
// rather than defining the vector again.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
#define EXPCL EXPCL_DTOOLCONFIG
|
||||
#define EXPTP EXPTP_DTOOLCONFIG
|
||||
#define EXPCL EXPCL_DTOOL
|
||||
#define EXPTP EXPTP_DTOOL
|
||||
#define TYPE int
|
||||
#define NAME vector_int
|
||||
|
||||
@ -19,7 +19,7 @@
|
||||
#include "notifyCategoryProxy.h"
|
||||
#include "configVariableSearchPath.h"
|
||||
|
||||
NotifyCategoryDecl(interrogatedb, EXPCL_DTOOLCONFIG, EXPTP_DTOOLCONFIG);
|
||||
NotifyCategoryDecl(interrogatedb, EXPCL_INTERROGATEDB, EXPTP_INTERROGATEDB);
|
||||
|
||||
extern ConfigVariableSearchPath interrogatedb_path;
|
||||
|
||||
|
||||
@ -30,7 +30,7 @@ PyMethodDef Dtool_Methods_DTOOL_SUPER_BASE[] = {
|
||||
{ NULL, NULL }
|
||||
};
|
||||
|
||||
EXPCL_DTOOLCONFIG void Dtool_PyModuleClassInit_DTOOL_SUPER_BASE(PyObject *module) {
|
||||
EXPCL_INTERROGATEDB void Dtool_PyModuleClassInit_DTOOL_SUPER_BASE(PyObject *module) {
|
||||
static bool initdone = false;
|
||||
if (!initdone) {
|
||||
|
||||
|
||||
@ -24,7 +24,7 @@
|
||||
// be used from the extension method.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class T>
|
||||
class EXPCL_DTOOLCONFIG ExtensionBase {
|
||||
class EXPCL_INTERROGATEDB ExtensionBase {
|
||||
public:
|
||||
T * _this;
|
||||
};
|
||||
@ -36,7 +36,7 @@ public:
|
||||
// a specialization of this class template.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
template<class T>
|
||||
class EXPCL_DTOOLCONFIG Extension : public ExtensionBase<T> {
|
||||
class EXPCL_INTERROGATEDB Extension : public ExtensionBase<T> {
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////
|
||||
|
||||
@ -30,7 +30,7 @@
|
||||
// only reason it exists is because Microsoft can't
|
||||
// export STL map outside of the DLL.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
class EXPCL_DTOOLCONFIG IndexRemapper {
|
||||
class EXPCL_INTERROGATEDB IndexRemapper {
|
||||
public:
|
||||
IndexRemapper();
|
||||
~IndexRemapper();
|
||||
|
||||
@ -30,7 +30,7 @@ class IndexRemapper;
|
||||
// interrogate database. This includes types,
|
||||
// functions, and function wrappers.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
class EXPCL_DTOOLCONFIG InterrogateComponent {
|
||||
class EXPCL_INTERROGATEDB InterrogateComponent {
|
||||
public:
|
||||
INLINE InterrogateComponent(InterrogateModuleDef *def = NULL);
|
||||
INLINE InterrogateComponent(const InterrogateComponent ©);
|
||||
|
||||
@ -35,7 +35,7 @@ class IndexRemapper;
|
||||
// Description : This stores all of the interrogate data and handles
|
||||
// reading the data from a disk file when necessary.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
class EXPCL_DTOOLCONFIG InterrogateDatabase {
|
||||
class EXPCL_INTERROGATEDB InterrogateDatabase {
|
||||
private:
|
||||
InterrogateDatabase();
|
||||
|
||||
|
||||
@ -26,7 +26,7 @@ class IndexRemapper;
|
||||
// Description : An internal representation of a data element, like a
|
||||
// data member or a global variable.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
class EXPCL_DTOOLCONFIG InterrogateElement : public InterrogateComponent {
|
||||
class EXPCL_INTERROGATEDB InterrogateElement : public InterrogateComponent {
|
||||
public:
|
||||
INLINE InterrogateElement(InterrogateModuleDef *def = NULL);
|
||||
INLINE InterrogateElement(const InterrogateElement ©);
|
||||
|
||||
@ -29,7 +29,7 @@ class CPPInstance;
|
||||
// Class : InterrogateFunction
|
||||
// Description : An internal representation of a function.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
class EXPCL_DTOOLCONFIG InterrogateFunction : public InterrogateComponent {
|
||||
class EXPCL_INTERROGATEDB InterrogateFunction : public InterrogateComponent {
|
||||
public:
|
||||
InterrogateFunction(InterrogateModuleDef *def = NULL);
|
||||
InterrogateFunction(const InterrogateFunction ©);
|
||||
|
||||
@ -27,7 +27,7 @@ class IndexRemapper;
|
||||
// Class : InterrogateFunctionWrapper
|
||||
// Description : An internal representation of a callable function.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
class EXPCL_DTOOLCONFIG InterrogateFunctionWrapper : public InterrogateComponent {
|
||||
class EXPCL_INTERROGATEDB InterrogateFunctionWrapper : public InterrogateComponent {
|
||||
public:
|
||||
INLINE InterrogateFunctionWrapper(InterrogateModuleDef *def = NULL);
|
||||
INLINE InterrogateFunctionWrapper(const InterrogateFunctionWrapper ©);
|
||||
|
||||
@ -26,7 +26,7 @@ class IndexRemapper;
|
||||
// Description : Represents a synthetic method created via the
|
||||
// MAKE_SEQ() macro.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
class EXPCL_DTOOLCONFIG InterrogateMakeSeq : public InterrogateComponent {
|
||||
class EXPCL_INTERROGATEDB InterrogateMakeSeq : public InterrogateComponent {
|
||||
public:
|
||||
INLINE InterrogateMakeSeq(InterrogateModuleDef *def = NULL);
|
||||
INLINE InterrogateMakeSeq(const InterrogateMakeSeq ©);
|
||||
|
||||
@ -25,7 +25,7 @@ class IndexRemapper;
|
||||
// Class : InterrogateManifest
|
||||
// Description : An internal representation of a manifest constant.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
class EXPCL_DTOOLCONFIG InterrogateManifest : public InterrogateComponent {
|
||||
class EXPCL_INTERROGATEDB InterrogateManifest : public InterrogateComponent {
|
||||
public:
|
||||
INLINE InterrogateManifest(InterrogateModuleDef *def = NULL);
|
||||
INLINE InterrogateManifest(const InterrogateManifest ©);
|
||||
|
||||
@ -29,7 +29,7 @@ class CPPScope;
|
||||
// Class : InterrogateType
|
||||
// Description : An internal representation of a type.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
class EXPCL_DTOOLCONFIG InterrogateType : public InterrogateComponent {
|
||||
class EXPCL_INTERROGATEDB InterrogateType : public InterrogateComponent {
|
||||
public:
|
||||
InterrogateType(InterrogateModuleDef *def = NULL);
|
||||
InterrogateType(const InterrogateType ©);
|
||||
|
||||
@ -87,9 +87,9 @@ enum AtomicToken {
|
||||
AT_longlong = 8
|
||||
};
|
||||
|
||||
EXPCL_DTOOLCONFIG void interrogate_add_search_directory(const char *dirname);
|
||||
EXPCL_DTOOLCONFIG void interrogate_add_search_path(const char *pathstring);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_error_flag();
|
||||
EXPCL_INTERROGATEDB void interrogate_add_search_directory(const char *dirname);
|
||||
EXPCL_INTERROGATEDB void interrogate_add_search_path(const char *pathstring);
|
||||
EXPCL_INTERROGATEDB bool interrogate_error_flag();
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
@ -107,23 +107,23 @@ EXPCL_DTOOLCONFIG bool interrogate_error_flag();
|
||||
// (whatever type interrogate thinks it is), as returned by the getter
|
||||
// function given by interrogate_manifest_getter().
|
||||
|
||||
EXPCL_DTOOLCONFIG int interrogate_number_of_manifests();
|
||||
EXPCL_DTOOLCONFIG ManifestIndex interrogate_get_manifest(int n);
|
||||
EXPCL_DTOOLCONFIG ManifestIndex interrogate_get_manifest_by_name(const char *manifest_name);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_manifest_name(ManifestIndex manifest);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_manifest_definition(ManifestIndex manifest);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_manifest_has_type(ManifestIndex manifest);
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_manifest_get_type(ManifestIndex manifest);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_manifest_has_getter(ManifestIndex manifest);
|
||||
EXPCL_DTOOLCONFIG FunctionIndex interrogate_manifest_getter(ManifestIndex manifest);
|
||||
EXPCL_INTERROGATEDB int interrogate_number_of_manifests();
|
||||
EXPCL_INTERROGATEDB ManifestIndex interrogate_get_manifest(int n);
|
||||
EXPCL_INTERROGATEDB ManifestIndex interrogate_get_manifest_by_name(const char *manifest_name);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_manifest_name(ManifestIndex manifest);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_manifest_definition(ManifestIndex manifest);
|
||||
EXPCL_INTERROGATEDB bool interrogate_manifest_has_type(ManifestIndex manifest);
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_manifest_get_type(ManifestIndex manifest);
|
||||
EXPCL_INTERROGATEDB bool interrogate_manifest_has_getter(ManifestIndex manifest);
|
||||
EXPCL_INTERROGATEDB FunctionIndex interrogate_manifest_getter(ManifestIndex manifest);
|
||||
|
||||
// An exception is made for manifest constants that have an integer
|
||||
// type value, since these are so common. The scripting language can
|
||||
// query these values directly, which saves having to generate a
|
||||
// wrapper function for each stupid little manifest. In this case,
|
||||
// there will be no getter function available.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_manifest_has_int_value(ManifestIndex manifest);
|
||||
EXPCL_DTOOLCONFIG int interrogate_manifest_get_int_value(ManifestIndex manifest);
|
||||
EXPCL_INTERROGATEDB bool interrogate_manifest_has_int_value(ManifestIndex manifest);
|
||||
EXPCL_INTERROGATEDB int interrogate_manifest_get_int_value(ManifestIndex manifest);
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
@ -136,12 +136,12 @@ EXPCL_DTOOLCONFIG int interrogate_manifest_get_int_value(ManifestIndex manifest)
|
||||
// elements. Interrogate automatically generates a getter function
|
||||
// and, if possible, a setter function.
|
||||
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_element_name(ElementIndex element);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_element_scoped_name(ElementIndex element);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_element_has_comment(ElementIndex element);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_element_comment(ElementIndex element);
|
||||
EXPCL_DTOOLCONFIG ElementIndex interrogate_get_element_by_name(const char *element_name);
|
||||
EXPCL_DTOOLCONFIG ElementIndex interrogate_get_element_by_scoped_name(const char *element_name);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_element_name(ElementIndex element);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_element_scoped_name(ElementIndex element);
|
||||
EXPCL_INTERROGATEDB bool interrogate_element_has_comment(ElementIndex element);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_element_comment(ElementIndex element);
|
||||
EXPCL_INTERROGATEDB ElementIndex interrogate_get_element_by_name(const char *element_name);
|
||||
EXPCL_INTERROGATEDB ElementIndex interrogate_get_element_by_scoped_name(const char *element_name);
|
||||
|
||||
// Be careful with this function. The element's bare type is not
|
||||
// likely to be directly useful to the scripting language. This is a
|
||||
@ -151,12 +151,12 @@ EXPCL_DTOOLCONFIG ElementIndex interrogate_get_element_by_scoped_name(const char
|
||||
// scripting language can't handle directly, e.g. a Node, while the
|
||||
// getter will return (and the setter accept) a pointer to a Node,
|
||||
// which is what the scripting language actually works with.
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_element_type(ElementIndex element);
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_element_type(ElementIndex element);
|
||||
|
||||
EXPCL_DTOOLCONFIG bool interrogate_element_has_getter(ElementIndex element);
|
||||
EXPCL_DTOOLCONFIG FunctionIndex interrogate_element_getter(ElementIndex element);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_element_has_setter(ElementIndex element);
|
||||
EXPCL_DTOOLCONFIG FunctionIndex interrogate_element_setter(ElementIndex element);
|
||||
EXPCL_INTERROGATEDB bool interrogate_element_has_getter(ElementIndex element);
|
||||
EXPCL_INTERROGATEDB FunctionIndex interrogate_element_getter(ElementIndex element);
|
||||
EXPCL_INTERROGATEDB bool interrogate_element_has_setter(ElementIndex element);
|
||||
EXPCL_INTERROGATEDB FunctionIndex interrogate_element_setter(ElementIndex element);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
@ -166,8 +166,8 @@ EXPCL_DTOOLCONFIG FunctionIndex interrogate_element_setter(ElementIndex element)
|
||||
|
||||
// This is the list of global data elements.
|
||||
|
||||
EXPCL_DTOOLCONFIG int interrogate_number_of_globals();
|
||||
EXPCL_DTOOLCONFIG ElementIndex interrogate_get_global(int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_number_of_globals();
|
||||
EXPCL_INTERROGATEDB ElementIndex interrogate_get_global(int n);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
@ -183,16 +183,16 @@ EXPCL_DTOOLCONFIG ElementIndex interrogate_get_global(int n);
|
||||
|
||||
// These are the global (nonmember) functions that appear outside of
|
||||
// any class definition.
|
||||
EXPCL_DTOOLCONFIG int interrogate_number_of_global_functions();
|
||||
EXPCL_DTOOLCONFIG FunctionIndex interrogate_get_global_function(int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_number_of_global_functions();
|
||||
EXPCL_INTERROGATEDB FunctionIndex interrogate_get_global_function(int n);
|
||||
|
||||
// This can be used to traverse through *all* the functions known to
|
||||
// interrogate. It's usually not what you want, since this includes
|
||||
// global functions, class methods, and synthesized functions like
|
||||
// upcasts and downcasts. You probably want to use instead
|
||||
// interrogate_number_of_global_functions(), above.
|
||||
EXPCL_DTOOLCONFIG int interrogate_number_of_functions();
|
||||
EXPCL_DTOOLCONFIG FunctionIndex interrogate_get_function(int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_number_of_functions();
|
||||
EXPCL_INTERROGATEDB FunctionIndex interrogate_get_function(int n);
|
||||
|
||||
// This is the function's name. It is not unique; it may be shared
|
||||
// between multiple different functions that have the same name but
|
||||
@ -200,42 +200,42 @@ EXPCL_DTOOLCONFIG FunctionIndex interrogate_get_function(int n);
|
||||
// Two different classes might also have member functions that have
|
||||
// the same name, or the same name as a global function (but also see
|
||||
// the scoped_name, below).
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_function_name(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_function_name(FunctionIndex function);
|
||||
|
||||
// The scoped name is the function name prefixed with the name of the
|
||||
// class that includes the function, if the function is a class
|
||||
// method. If it is a global function, the scoped name is the same as
|
||||
// the name returned above. In the absence of C++ function
|
||||
// overloading, this name will be unique to each function.
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_function_scoped_name(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_function_scoped_name(FunctionIndex function);
|
||||
|
||||
// This returns the C++ comment written for the function, either in
|
||||
// the header file or in the .C file, or both.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_function_has_comment(FunctionIndex function);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_function_comment(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB bool interrogate_function_has_comment(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_function_comment(FunctionIndex function);
|
||||
|
||||
// This defines the function prototype as it appears in the C++
|
||||
// source, useful primarily for documentation purposes.
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_function_prototype(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_function_prototype(FunctionIndex function);
|
||||
|
||||
// This can be used to determine the class that the function is a
|
||||
// method for, if the function is a class method.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_function_is_method(FunctionIndex function);
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_function_class(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB bool interrogate_function_is_method(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_function_class(FunctionIndex function);
|
||||
|
||||
// This returns the module name reported for the function, if
|
||||
// available.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_function_has_module_name(FunctionIndex function);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_function_module_name(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB bool interrogate_function_has_module_name(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_function_module_name(FunctionIndex function);
|
||||
|
||||
// This returns the library name reported for the function, if
|
||||
// available.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_function_has_library_name(FunctionIndex function);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_function_library_name(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB bool interrogate_function_has_library_name(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_function_library_name(FunctionIndex function);
|
||||
|
||||
// This is true for virtual member functions. It's not likely that
|
||||
// this will be important to the scripting language.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_function_is_virtual(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB bool interrogate_function_is_virtual(FunctionIndex function);
|
||||
|
||||
|
||||
// The actual callable function interface is defined via one or more
|
||||
@ -246,11 +246,11 @@ EXPCL_DTOOLCONFIG bool interrogate_function_is_virtual(FunctionIndex function);
|
||||
// calling convention or the Python calling convention. The set of
|
||||
// wrappers that will actually be available depends on the parameters
|
||||
// passed to the interrogate command line.
|
||||
EXPCL_DTOOLCONFIG int interrogate_function_number_of_c_wrappers(FunctionIndex function);
|
||||
EXPCL_DTOOLCONFIG FunctionWrapperIndex interrogate_function_c_wrapper(FunctionIndex function, int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_function_number_of_c_wrappers(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB FunctionWrapperIndex interrogate_function_c_wrapper(FunctionIndex function, int n);
|
||||
|
||||
EXPCL_DTOOLCONFIG int interrogate_function_number_of_python_wrappers(FunctionIndex function);
|
||||
EXPCL_DTOOLCONFIG FunctionWrapperIndex interrogate_function_python_wrapper(FunctionIndex function, int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_function_number_of_python_wrappers(FunctionIndex function);
|
||||
EXPCL_INTERROGATEDB FunctionWrapperIndex interrogate_function_python_wrapper(FunctionIndex function, int n);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
@ -273,17 +273,17 @@ EXPCL_DTOOLCONFIG FunctionWrapperIndex interrogate_function_python_wrapper(Funct
|
||||
|
||||
// Don't confuse this with the unique_name, below. The two are
|
||||
// related, but not identical.
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_wrapper_name(FunctionWrapperIndex wrapper);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_wrapper_name(FunctionWrapperIndex wrapper);
|
||||
|
||||
// This returns true if -fnames was given to interrogate, making the
|
||||
// wrapper function callable directly by its name.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_wrapper_is_callable_by_name(FunctionWrapperIndex wrapper);
|
||||
EXPCL_INTERROGATEDB bool interrogate_wrapper_is_callable_by_name(FunctionWrapperIndex wrapper);
|
||||
|
||||
// This returns the C++ comment written for the function wrapper,
|
||||
// usually from the .cpp file. There may be a different comment for
|
||||
// each overload of a given function.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_wrapper_has_comment(FunctionWrapperIndex wrapper);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_wrapper_comment(FunctionWrapperIndex wrapper);
|
||||
EXPCL_INTERROGATEDB bool interrogate_wrapper_has_comment(FunctionWrapperIndex wrapper);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_wrapper_comment(FunctionWrapperIndex wrapper);
|
||||
|
||||
// Every function wrapper has zero or more parameters and may or may
|
||||
// not have a return value. Each parameter has a type and may or may
|
||||
@ -293,8 +293,8 @@ EXPCL_DTOOLCONFIG const char *interrogate_wrapper_comment(FunctionWrapperIndex w
|
||||
// its first parameter, it is a static member function, also called a
|
||||
// class method.)
|
||||
|
||||
EXPCL_DTOOLCONFIG bool interrogate_wrapper_has_return_value(FunctionWrapperIndex wrapper);
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_wrapper_return_type(FunctionWrapperIndex wrapper);
|
||||
EXPCL_INTERROGATEDB bool interrogate_wrapper_has_return_value(FunctionWrapperIndex wrapper);
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_wrapper_return_type(FunctionWrapperIndex wrapper);
|
||||
|
||||
// Sometimes interrogate must synthesize a wrapper that allocates its
|
||||
// return value from the free store. Other times (especially if
|
||||
@ -309,15 +309,15 @@ EXPCL_DTOOLCONFIG TypeIndex interrogate_wrapper_return_type(FunctionWrapperIndex
|
||||
// that for the class). Otherwise, this function will return false,
|
||||
// and the scripting language should *not* call any destructor on this
|
||||
// value.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_wrapper_caller_manages_return_value(FunctionWrapperIndex wrapper);
|
||||
EXPCL_DTOOLCONFIG FunctionIndex interrogate_wrapper_return_value_destructor(FunctionWrapperIndex wrapper);
|
||||
EXPCL_INTERROGATEDB bool interrogate_wrapper_caller_manages_return_value(FunctionWrapperIndex wrapper);
|
||||
EXPCL_INTERROGATEDB FunctionIndex interrogate_wrapper_return_value_destructor(FunctionWrapperIndex wrapper);
|
||||
|
||||
// These define the parameters of the function.
|
||||
EXPCL_DTOOLCONFIG int interrogate_wrapper_number_of_parameters(FunctionWrapperIndex wrapper);
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_wrapper_parameter_type(FunctionWrapperIndex wrapper, int n);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_wrapper_parameter_has_name(FunctionWrapperIndex wrapper, int n);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_wrapper_parameter_name(FunctionWrapperIndex wrapper, int n);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_wrapper_parameter_is_this(FunctionWrapperIndex wrapper, int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_wrapper_number_of_parameters(FunctionWrapperIndex wrapper);
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_wrapper_parameter_type(FunctionWrapperIndex wrapper, int n);
|
||||
EXPCL_INTERROGATEDB bool interrogate_wrapper_parameter_has_name(FunctionWrapperIndex wrapper, int n);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_wrapper_parameter_name(FunctionWrapperIndex wrapper, int n);
|
||||
EXPCL_INTERROGATEDB bool interrogate_wrapper_parameter_is_this(FunctionWrapperIndex wrapper, int n);
|
||||
|
||||
// This returns a pointer to a function that may be called to invoke
|
||||
// the function, if the -fptrs option to return function pointers was
|
||||
@ -327,8 +327,8 @@ EXPCL_DTOOLCONFIG bool interrogate_wrapper_parameter_is_this(FunctionWrapperInde
|
||||
|
||||
// These two functions may be called without forcing a load of the
|
||||
// complete interrogate database.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_wrapper_has_pointer(FunctionWrapperIndex wrapper);
|
||||
EXPCL_DTOOLCONFIG void *interrogate_wrapper_pointer(FunctionWrapperIndex wrapper);
|
||||
EXPCL_INTERROGATEDB bool interrogate_wrapper_has_pointer(FunctionWrapperIndex wrapper);
|
||||
EXPCL_INTERROGATEDB void *interrogate_wrapper_pointer(FunctionWrapperIndex wrapper);
|
||||
|
||||
// This function will return a name that is guaranteed to be unique to
|
||||
// this particular function wrapper, and that will (usually) be
|
||||
@ -339,7 +339,7 @@ EXPCL_DTOOLCONFIG void *interrogate_wrapper_pointer(FunctionWrapperIndex wrapper
|
||||
// The unique name is an ugly hashed name, not safe for human
|
||||
// consumption. Its sole purpose is to provide some consistent way to
|
||||
// identify function wrappers between sessions.
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_wrapper_unique_name(FunctionWrapperIndex wrapper);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_wrapper_unique_name(FunctionWrapperIndex wrapper);
|
||||
|
||||
// This function provides a reverse-lookup on the above unique name,
|
||||
// returning the wrapper index corresponding to the given name. It
|
||||
@ -349,7 +349,7 @@ EXPCL_DTOOLCONFIG const char *interrogate_wrapper_unique_name(FunctionWrapperInd
|
||||
|
||||
// This function may be called without forcing a load of the complete
|
||||
// interrogate database.
|
||||
EXPCL_DTOOLCONFIG FunctionWrapperIndex interrogate_get_wrapper_by_unique_name(const char *unique_name);
|
||||
EXPCL_INTERROGATEDB FunctionWrapperIndex interrogate_get_wrapper_by_unique_name(const char *unique_name);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
@ -364,14 +364,14 @@ EXPCL_DTOOLCONFIG FunctionWrapperIndex interrogate_get_wrapper_by_unique_name(co
|
||||
// get_things().
|
||||
|
||||
// The class of which the make_seq is a method.
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_make_seq_class(MakeSeqIndex make_seq);
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_make_seq_class(MakeSeqIndex make_seq);
|
||||
|
||||
// The name of the syntheized method, e.g. "get_things"
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_make_seq_seq_name(MakeSeqIndex make_seq);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_make_seq_seq_name(MakeSeqIndex make_seq);
|
||||
// The name of the real method that returns the length, e.g. "get_num_things"
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_make_seq_num_name(MakeSeqIndex make_seq);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_make_seq_num_name(MakeSeqIndex make_seq);
|
||||
// The name of the real method that returns the nth element, e.g. "get_thing"
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_make_seq_element_name(MakeSeqIndex make_seq);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_make_seq_element_name(MakeSeqIndex make_seq);
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
@ -393,16 +393,16 @@ EXPCL_DTOOLCONFIG const char *interrogate_make_seq_element_name(MakeSeqIndex mak
|
||||
// classes. These types are necessary to fully define all of the
|
||||
// function parameters, but need not themselves be wrapped.
|
||||
|
||||
EXPCL_DTOOLCONFIG int interrogate_number_of_global_types();
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_get_global_type(int n);
|
||||
EXPCL_DTOOLCONFIG int interrogate_number_of_types();
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_get_type(int n);
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_get_type_by_name(const char *type_name);
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_get_type_by_scoped_name(const char *type_name);
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_get_type_by_true_name(const char *type_name);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_type_name(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_type_scoped_name(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_type_true_name(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB int interrogate_number_of_global_types();
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_get_global_type(int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_number_of_types();
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_get_type(int n);
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_get_type_by_name(const char *type_name);
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_get_type_by_scoped_name(const char *type_name);
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_get_type_by_true_name(const char *type_name);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_type_name(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_type_scoped_name(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_type_true_name(TypeIndex type);
|
||||
|
||||
// A given type might be a nested type, meaning it is entirely defined
|
||||
// within (and scoped within) some different C++ class. In this case,
|
||||
@ -410,32 +410,32 @@ EXPCL_DTOOLCONFIG const char *interrogate_type_true_name(TypeIndex type);
|
||||
// within the class, while the scoped_name() will return the
|
||||
// fully-qualified name of the type, and is_nested() and outer_class()
|
||||
// can be used to determine the class it is nested within.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_nested(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_type_outer_class(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_nested(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_type_outer_class(TypeIndex type);
|
||||
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_has_comment(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_type_comment(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_has_comment(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_type_comment(TypeIndex type);
|
||||
|
||||
// This returns the module name reported for the type, if available.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_has_module_name(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_type_module_name(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_has_module_name(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_type_module_name(TypeIndex type);
|
||||
|
||||
// This returns the library name reported for the type, if available.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_has_library_name(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_type_library_name(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_has_library_name(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_type_library_name(TypeIndex type);
|
||||
|
||||
|
||||
// If interrogate_type_is_atomic() returns true, the type is one of
|
||||
// the basic C types enumerated in AtomicToken, above. The type may
|
||||
// then be further modified by one or more of unsigned, signed, long,
|
||||
// longlong, or short. However, it will not be a pointer.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_atomic(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG AtomicToken interrogate_type_atomic_token(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_unsigned(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_signed(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_long(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_longlong(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_short(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_atomic(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB AtomicToken interrogate_type_atomic_token(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_unsigned(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_signed(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_long(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_longlong(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_short(TypeIndex type);
|
||||
|
||||
// If interrogate_type_is_wrapped() returns true, this is a composite
|
||||
// type "wrapped" around some simpler type, for instance a pointer to
|
||||
@ -444,21 +444,21 @@ EXPCL_DTOOLCONFIG bool interrogate_type_is_short(TypeIndex type);
|
||||
// they use multiple wrappers. A const char pointer, for example, is
|
||||
// represented as a pointer wrapper around a const wrapper around an
|
||||
// atomic char.)
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_wrapped(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_pointer(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_const(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_typedef(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_type_wrapped_type(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_wrapped(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_pointer(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_const(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_typedef(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_type_wrapped_type(TypeIndex type);
|
||||
|
||||
// If interrogate_type_is_enum() returns true, this is an enumerated
|
||||
// type, which means it may take any one of a number of named integer
|
||||
// values.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_enum(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG int interrogate_type_number_of_enum_values(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_type_enum_value_name(TypeIndex type, int n);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_type_enum_value_scoped_name(TypeIndex type, int n);
|
||||
EXPCL_DTOOLCONFIG const char *interrogate_type_enum_value_comment(TypeIndex type, int n);
|
||||
EXPCL_DTOOLCONFIG int interrogate_type_enum_value(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_enum(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB int interrogate_type_number_of_enum_values(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_type_enum_value_name(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_type_enum_value_scoped_name(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB const char *interrogate_type_enum_value_comment(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_type_enum_value(TypeIndex type, int n);
|
||||
|
||||
// If none of the above is true, the type is some extension type. It
|
||||
// may be a struct, class, or union (and the distinction between these
|
||||
@ -466,19 +466,19 @@ EXPCL_DTOOLCONFIG int interrogate_type_enum_value(TypeIndex type, int n);
|
||||
// any case, it may contain zero or more constructors, zero or one
|
||||
// destructor, zero or more member functions, and zero or more data
|
||||
// members; all of the remaining type functions may apply.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_struct(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_class(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_union(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_struct(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_class(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_union(TypeIndex type);
|
||||
|
||||
// If is_fully_defined() returns false, this class/struct was a
|
||||
// forward reference, and we really don't know anything about it. (In
|
||||
// this case, it will appear to have no methods or members.)
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_fully_defined(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_fully_defined(TypeIndex type);
|
||||
|
||||
// If is_unpublished() returns false, the class/struct is unknown
|
||||
// because it was not marked to be published (or, in promiscuous mode,
|
||||
// it is a protected or private nested class).
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_is_unpublished(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_is_unpublished(TypeIndex type);
|
||||
|
||||
// Otherwise, especially if the type is a struct or class, we may have
|
||||
// a number of member functions, including zero or more constructors
|
||||
@ -499,36 +499,36 @@ EXPCL_DTOOLCONFIG bool interrogate_type_is_unpublished(TypeIndex type);
|
||||
// same function index as the one returned by the ancestor class, and
|
||||
// interrogate_type_destructor_is_inherited() will return true for
|
||||
// this class.
|
||||
EXPCL_DTOOLCONFIG int interrogate_type_number_of_constructors(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG FunctionIndex interrogate_type_get_constructor(TypeIndex type, int n);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_has_destructor(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_destructor_is_inherited(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG FunctionIndex interrogate_type_get_destructor(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB int interrogate_type_number_of_constructors(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB FunctionIndex interrogate_type_get_constructor(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_has_destructor(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_destructor_is_inherited(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB FunctionIndex interrogate_type_get_destructor(TypeIndex type);
|
||||
|
||||
// This is the set of exposed data elements in the struct or class.
|
||||
EXPCL_DTOOLCONFIG int interrogate_type_number_of_elements(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG ElementIndex interrogate_type_get_element(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_type_number_of_elements(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB ElementIndex interrogate_type_get_element(TypeIndex type, int n);
|
||||
|
||||
// This is the set of exposed member functions in the struct or class.
|
||||
EXPCL_DTOOLCONFIG int interrogate_type_number_of_methods(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG FunctionIndex interrogate_type_get_method(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_type_number_of_methods(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB FunctionIndex interrogate_type_get_method(TypeIndex type, int n);
|
||||
|
||||
// This is the set of MAKE_SEQ wrappers in the struct or class.
|
||||
EXPCL_DTOOLCONFIG int interrogate_type_number_of_make_seqs(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG MakeSeqIndex interrogate_type_get_make_seq(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_type_number_of_make_seqs(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB MakeSeqIndex interrogate_type_get_make_seq(TypeIndex type, int n);
|
||||
|
||||
// A C++ class may also define a number of explicit cast operators,
|
||||
// which define how to convert an object of this type to an object of
|
||||
// some other type (the type can be inferred by the return type of the
|
||||
// cast function). This is not related to upcast and downcast,
|
||||
// defined below.
|
||||
EXPCL_DTOOLCONFIG int interrogate_type_number_of_casts(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG FunctionIndex interrogate_type_get_cast(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_type_number_of_casts(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB FunctionIndex interrogate_type_get_cast(TypeIndex type, int n);
|
||||
|
||||
// A C++ class may inherit from zero or more base classes. This
|
||||
// defines the list of base classes for this particular type.
|
||||
EXPCL_DTOOLCONFIG int interrogate_type_number_of_derivations(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_type_get_derivation(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_type_number_of_derivations(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_type_get_derivation(TypeIndex type, int n);
|
||||
|
||||
// For each base class, we might need to define an explicit upcast or
|
||||
// downcast operation to convert the pointer to the derived class to
|
||||
@ -544,8 +544,8 @@ EXPCL_DTOOLCONFIG TypeIndex interrogate_type_get_derivation(TypeIndex type, int
|
||||
// class. If this returns false, you may simply use the same pointer
|
||||
// as either a derived class pointer or a base class pointer without
|
||||
// any extra step.
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_derivation_has_upcast(TypeIndex type, int n);
|
||||
EXPCL_DTOOLCONFIG FunctionIndex interrogate_type_get_upcast(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_derivation_has_upcast(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB FunctionIndex interrogate_type_get_upcast(TypeIndex type, int n);
|
||||
|
||||
// Although it is always possible to upcast a pointer to a base class,
|
||||
// it is not always possible to downcast from a base class to the
|
||||
@ -555,14 +555,14 @@ EXPCL_DTOOLCONFIG FunctionIndex interrogate_type_get_upcast(TypeIndex type, int
|
||||
// way as upcasting. (Of course, it is the caller's responsibility to
|
||||
// guarantee that the pointer actually represents an object of the
|
||||
// type being downcast to.)
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_derivation_downcast_is_impossible(TypeIndex type, int n);
|
||||
EXPCL_DTOOLCONFIG bool interrogate_type_derivation_has_downcast(TypeIndex type, int n);
|
||||
EXPCL_DTOOLCONFIG FunctionIndex interrogate_type_get_downcast(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_derivation_downcast_is_impossible(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB bool interrogate_type_derivation_has_downcast(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB FunctionIndex interrogate_type_get_downcast(TypeIndex type, int n);
|
||||
|
||||
// A C++ class may also define any number of nested types--classes or
|
||||
// enums defined within the scope of this class.
|
||||
EXPCL_DTOOLCONFIG int interrogate_type_number_of_nested_types(TypeIndex type);
|
||||
EXPCL_DTOOLCONFIG TypeIndex interrogate_type_get_nested_type(TypeIndex type, int n);
|
||||
EXPCL_INTERROGATEDB int interrogate_type_number_of_nested_types(TypeIndex type);
|
||||
EXPCL_INTERROGATEDB TypeIndex interrogate_type_get_nested_type(TypeIndex type, int n);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
@ -39,7 +39,7 @@ extern "C" {
|
||||
* data available, but doesn't allow matching the database information
|
||||
* up with any compiled-in function wrappers or anything.
|
||||
*/
|
||||
EXPCL_DTOOLCONFIG void interrogate_request_database(const char *database_filename);
|
||||
EXPCL_INTERROGATEDB void interrogate_request_database(const char *database_filename);
|
||||
|
||||
|
||||
|
||||
@ -74,7 +74,7 @@ typedef struct {
|
||||
* This includes all of the function pointers and/or unique names that
|
||||
* might be compiled in.
|
||||
*/
|
||||
EXPCL_DTOOLCONFIG void interrogate_request_module(InterrogateModuleDef *def);
|
||||
EXPCL_INTERROGATEDB void interrogate_request_module(InterrogateModuleDef *def);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
@ -5,7 +5,6 @@
|
||||
#include "interrogate_interface.cxx"
|
||||
#include "interrogate_request.cxx"
|
||||
#include "py_panda.cxx"
|
||||
#include "vector_int.cxx"
|
||||
|
||||
|
||||
|
||||
|
||||
@ -848,7 +848,7 @@ PyObject *map_deepcopy_to_copy(PyObject *self, PyObject *args) {
|
||||
// to whether the indicated value will fit.
|
||||
////////////////////////////////////////////////////////////////////
|
||||
#if PY_MAJOR_VERSION < 3
|
||||
EXPCL_DTOOLCONFIG PyObject *
|
||||
EXPCL_INTERROGATEDB PyObject *
|
||||
PyLongOrInt_FromUnsignedLong(unsigned long value) {
|
||||
if ((long)value < 0) {
|
||||
return PyLong_FromUnsignedLong(value);
|
||||
|
||||
@ -187,7 +187,7 @@ struct Dtool_PyInstDef {
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
// A Offset Dictionary Defining How to read the Above Object..
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
extern EXPCL_DTOOLCONFIG PyMemberDef standard_type_members[];
|
||||
extern EXPCL_INTERROGATEDB PyMemberDef standard_type_members[];
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
// The Class Definition Structor For a Dtool python type.
|
||||
@ -281,7 +281,7 @@ static void Dtool_FreeInstance_##CLASS_NAME(PyObject *self) {\
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// Simple Recognition Functions..
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
EXPCL_DTOOLCONFIG bool DtoolCanThisBeAPandaInstance(PyObject *self);
|
||||
EXPCL_INTERROGATEDB bool DtoolCanThisBeAPandaInstance(PyObject *self);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// ** HACK ** allert..
|
||||
@ -291,15 +291,15 @@ EXPCL_DTOOLCONFIG bool DtoolCanThisBeAPandaInstance(PyObject *self);
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
EXPCL_DTOOLCONFIG void RegisterNamedClass(const string &name, Dtool_PyTypedObject &otype);
|
||||
EXPCL_DTOOLCONFIG void RegisterRuntimeTypedClass(Dtool_PyTypedObject &otype);
|
||||
EXPCL_INTERROGATEDB void RegisterNamedClass(const string &name, Dtool_PyTypedObject &otype);
|
||||
EXPCL_INTERROGATEDB void RegisterRuntimeTypedClass(Dtool_PyTypedObject &otype);
|
||||
|
||||
EXPCL_DTOOLCONFIG Dtool_PyTypedObject *LookupNamedClass(const string &name);
|
||||
EXPCL_DTOOLCONFIG Dtool_PyTypedObject *LookupRuntimeTypedClass(TypeHandle handle);
|
||||
EXPCL_INTERROGATEDB Dtool_PyTypedObject *LookupNamedClass(const string &name);
|
||||
EXPCL_INTERROGATEDB Dtool_PyTypedObject *LookupRuntimeTypedClass(TypeHandle handle);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
EXPCL_DTOOLCONFIG Dtool_PyTypedObject *Dtool_RuntimeTypeDtoolType(int type);
|
||||
EXPCL_INTERROGATEDB Dtool_PyTypedObject *Dtool_RuntimeTypeDtoolType(int type);
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
// Function : DTOOL_Call_ExtractThisPointerForType
|
||||
@ -309,15 +309,15 @@ EXPCL_DTOOLCONFIG Dtool_PyTypedObject *Dtool_RuntimeTypeDtoolType(int type);
|
||||
// with these as the generated code depends on how this is set
|
||||
// up..
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
EXPCL_DTOOLCONFIG void DTOOL_Call_ExtractThisPointerForType(PyObject *self, Dtool_PyTypedObject *classdef, void **answer);
|
||||
EXPCL_INTERROGATEDB void DTOOL_Call_ExtractThisPointerForType(PyObject *self, Dtool_PyTypedObject *classdef, void **answer);
|
||||
|
||||
EXPCL_DTOOLCONFIG void *DTOOL_Call_GetPointerThisClass(PyObject *self, Dtool_PyTypedObject *classdef, int param, const string &function_name, bool const_ok, bool report_errors);
|
||||
EXPCL_INTERROGATEDB void *DTOOL_Call_GetPointerThisClass(PyObject *self, Dtool_PyTypedObject *classdef, int param, const string &function_name, bool const_ok, bool report_errors);
|
||||
|
||||
EXPCL_DTOOLCONFIG void *DTOOL_Call_GetPointerThis(PyObject *self);
|
||||
EXPCL_INTERROGATEDB void *DTOOL_Call_GetPointerThis(PyObject *self);
|
||||
|
||||
EXPCL_DTOOLCONFIG bool Dtool_Call_ExtractThisPointer(PyObject *self, Dtool_PyTypedObject &classdef, void **answer);
|
||||
EXPCL_INTERROGATEDB bool Dtool_Call_ExtractThisPointer(PyObject *self, Dtool_PyTypedObject &classdef, void **answer);
|
||||
|
||||
EXPCL_DTOOLCONFIG bool Dtool_Call_ExtractThisPointer_NonConst(PyObject *self, Dtool_PyTypedObject &classdef,
|
||||
EXPCL_INTERROGATEDB bool Dtool_Call_ExtractThisPointer_NonConst(PyObject *self, Dtool_PyTypedObject &classdef,
|
||||
void **answer, const char *method_name);
|
||||
|
||||
template<class T> INLINE bool DTOOL_Call_ExtractThisPointer(PyObject *self, T *&into) {
|
||||
@ -338,15 +338,15 @@ template<class T> INLINE bool DTOOL_Call_ExtractThisPointer(PyObject *self, T *&
|
||||
// _PyErr_OCCURRED is an undocumented inline version of PyErr_Occurred.
|
||||
#define Dtool_CheckErrorOccurred() (_PyErr_OCCURRED() != NULL)
|
||||
#else
|
||||
EXPCL_DTOOLCONFIG bool Dtool_CheckErrorOccurred();
|
||||
EXPCL_INTERROGATEDB bool Dtool_CheckErrorOccurred();
|
||||
#endif
|
||||
|
||||
EXPCL_DTOOLCONFIG PyObject *Dtool_Raise_AssertionError();
|
||||
EXPCL_DTOOLCONFIG PyObject *Dtool_Raise_TypeError(const char *message);
|
||||
EXPCL_DTOOLCONFIG PyObject *Dtool_Raise_ArgTypeError(PyObject *obj, int param, const char *function_name, const char *type_name);
|
||||
EXPCL_DTOOLCONFIG PyObject *Dtool_Raise_AttributeError(PyObject *obj, const char *attribute);
|
||||
EXPCL_INTERROGATEDB PyObject *Dtool_Raise_AssertionError();
|
||||
EXPCL_INTERROGATEDB PyObject *Dtool_Raise_TypeError(const char *message);
|
||||
EXPCL_INTERROGATEDB PyObject *Dtool_Raise_ArgTypeError(PyObject *obj, int param, const char *function_name, const char *type_name);
|
||||
EXPCL_INTERROGATEDB PyObject *Dtool_Raise_AttributeError(PyObject *obj, const char *attribute);
|
||||
|
||||
EXPCL_DTOOLCONFIG PyObject *_Dtool_Raise_BadArgumentsError();
|
||||
EXPCL_INTERROGATEDB PyObject *_Dtool_Raise_BadArgumentsError();
|
||||
#ifdef NDEBUG
|
||||
// Define it to a function that just prints a generic message.
|
||||
#define Dtool_Raise_BadArgumentsError(x) _Dtool_Raise_BadArgumentsError()
|
||||
@ -355,9 +355,9 @@ EXPCL_DTOOLCONFIG PyObject *_Dtool_Raise_BadArgumentsError();
|
||||
#define Dtool_Raise_BadArgumentsError(x) Dtool_Raise_TypeError("Arguments must match:\n" x)
|
||||
#endif
|
||||
|
||||
EXPCL_DTOOLCONFIG PyObject *_Dtool_Return_None();
|
||||
EXPCL_DTOOLCONFIG PyObject *Dtool_Return_Bool(bool value);
|
||||
EXPCL_DTOOLCONFIG PyObject *_Dtool_Return(PyObject *value);
|
||||
EXPCL_INTERROGATEDB PyObject *_Dtool_Return_None();
|
||||
EXPCL_INTERROGATEDB PyObject *Dtool_Return_Bool(bool value);
|
||||
EXPCL_INTERROGATEDB PyObject *_Dtool_Return(PyObject *value);
|
||||
|
||||
#ifdef NDEBUG
|
||||
#define Dtool_Return_None() (_PyErr_OCCURRED() != NULL ? NULL : (Py_INCREF(Py_None), Py_None))
|
||||
@ -373,13 +373,13 @@ EXPCL_DTOOLCONFIG PyObject *_Dtool_Return(PyObject *value);
|
||||
// this function relies on the behavior of typed objects in the panda system.
|
||||
//
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
EXPCL_DTOOLCONFIG PyObject *DTool_CreatePyInstanceTyped(void *local_this_in, Dtool_PyTypedObject &known_class_type, bool memory_rules, bool is_const, int RunTimeType);
|
||||
EXPCL_INTERROGATEDB PyObject *DTool_CreatePyInstanceTyped(void *local_this_in, Dtool_PyTypedObject &known_class_type, bool memory_rules, bool is_const, int RunTimeType);
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
// DTool_CreatePyInstance .. wrapper function to finalize the existance of a general
|
||||
// dtool py instance..
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
EXPCL_DTOOLCONFIG PyObject *DTool_CreatePyInstance(void *local_this, Dtool_PyTypedObject &in_classdef, bool memory_rules, bool is_const);
|
||||
EXPCL_INTERROGATEDB PyObject *DTool_CreatePyInstance(void *local_this, Dtool_PyTypedObject &in_classdef, bool memory_rules, bool is_const);
|
||||
|
||||
// These template methods allow use when the Dtool_PyTypedObject is not known.
|
||||
// They require a get_class_type() to be defined for the class.
|
||||
@ -450,7 +450,7 @@ Define_Dtool_Class(MODULE_NAME,CLASS_NAME,PUBLIC_NAME)
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// Th Finalizer for simple instances..
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
EXPCL_DTOOLCONFIG int DTool_PyInit_Finalize(PyObject *self, void *This, Dtool_PyTypedObject *type, bool memory_rules, bool is_const);
|
||||
EXPCL_INTERROGATEDB int DTool_PyInit_Finalize(PyObject *self, void *This, Dtool_PyTypedObject *type, bool memory_rules, bool is_const);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// A heler function to glu methed definition together .. that can not be done at
|
||||
@ -459,7 +459,7 @@ EXPCL_DTOOLCONFIG int DTool_PyInit_Finalize(PyObject *self, void *This, Dtool_Py
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
typedef std::map<std::string, PyMethodDef *> MethodDefmap;
|
||||
|
||||
EXPCL_DTOOLCONFIG void Dtool_Accum_MethDefs(PyMethodDef in[], MethodDefmap &themap);
|
||||
EXPCL_INTERROGATEDB void Dtool_Accum_MethDefs(PyMethodDef in[], MethodDefmap &themap);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//// We need a way to runtime merge compile units into a python "Module" .. this is done with the
|
||||
@ -471,9 +471,9 @@ struct LibraryDef {
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#if PY_MAJOR_VERSION >= 3
|
||||
EXPCL_DTOOLCONFIG PyObject *Dtool_PyModuleInitHelper(LibraryDef *defs[], PyModuleDef *module_def);
|
||||
EXPCL_INTERROGATEDB PyObject *Dtool_PyModuleInitHelper(LibraryDef *defs[], PyModuleDef *module_def);
|
||||
#else
|
||||
EXPCL_DTOOLCONFIG PyObject *Dtool_PyModuleInitHelper(LibraryDef *defs[], const char *modulename);
|
||||
EXPCL_INTERROGATEDB PyObject *Dtool_PyModuleInitHelper(LibraryDef *defs[], const char *modulename);
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
@ -484,16 +484,16 @@ EXPCL_DTOOLCONFIG PyObject *Dtool_PyModuleInitHelper(LibraryDef *defs[], const c
|
||||
// Required to support fom historical inharatence in the for of "is this instance of"..
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
EXPCL_DTOOLCONFIG PyObject *Dtool_BorrowThisReference(PyObject *self, PyObject *args);
|
||||
EXPCL_INTERROGATEDB PyObject *Dtool_BorrowThisReference(PyObject *self, PyObject *args);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// We do expose a dictionay for dtool classes .. this should be removed at some point..
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////
|
||||
EXPCL_DTOOLCONFIG PyObject *Dtool_AddToDictionary(PyObject *self1, PyObject *args);
|
||||
EXPCL_INTERROGATEDB PyObject *Dtool_AddToDictionary(PyObject *self1, PyObject *args);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
EXPCL_DTOOLCONFIG Py_hash_t DTOOL_PyObject_HashPointer(PyObject *obj);
|
||||
EXPCL_INTERROGATEDB Py_hash_t DTOOL_PyObject_HashPointer(PyObject *obj);
|
||||
|
||||
/* Compare v to w. Return
|
||||
-1 if v < w or exception (PyErr_Occurred() true in latter case).
|
||||
@ -503,28 +503,28 @@ EXPCL_DTOOLCONFIG Py_hash_t DTOOL_PyObject_HashPointer(PyObject *obj);
|
||||
XXX of error.
|
||||
*/
|
||||
|
||||
EXPCL_DTOOLCONFIG int DTOOL_PyObject_ComparePointers(PyObject *v1, PyObject *v2);
|
||||
EXPCL_DTOOLCONFIG int DTOOL_PyObject_Compare(PyObject *v1, PyObject *v2);
|
||||
EXPCL_INTERROGATEDB int DTOOL_PyObject_ComparePointers(PyObject *v1, PyObject *v2);
|
||||
EXPCL_INTERROGATEDB int DTOOL_PyObject_Compare(PyObject *v1, PyObject *v2);
|
||||
|
||||
EXPCL_DTOOLCONFIG PyObject *DTOOL_PyObject_RichCompare(PyObject *v1, PyObject *v2, int op);
|
||||
EXPCL_INTERROGATEDB PyObject *DTOOL_PyObject_RichCompare(PyObject *v1, PyObject *v2, int op);
|
||||
|
||||
EXPCL_DTOOLCONFIG PyObject *
|
||||
EXPCL_INTERROGATEDB PyObject *
|
||||
copy_from_make_copy(PyObject *self, PyObject *noargs);
|
||||
|
||||
EXPCL_DTOOLCONFIG PyObject *
|
||||
EXPCL_INTERROGATEDB PyObject *
|
||||
copy_from_copy_constructor(PyObject *self, PyObject *noargs);
|
||||
|
||||
EXPCL_DTOOLCONFIG PyObject *
|
||||
EXPCL_INTERROGATEDB PyObject *
|
||||
map_deepcopy_to_copy(PyObject *self, PyObject *args);
|
||||
|
||||
#if PY_MAJOR_VERSION < 3
|
||||
// In the Python 3 case, it is defined as a macro, at the beginning of this file.
|
||||
EXPCL_DTOOLCONFIG PyObject *
|
||||
EXPCL_INTERROGATEDB PyObject *
|
||||
PyLongOrInt_FromUnsignedLong(unsigned long value);
|
||||
#endif
|
||||
|
||||
EXPCL_DTOOLCONFIG extern struct Dtool_PyTypedObject Dtool_DTOOL_SUPER_BASE;
|
||||
EXPCL_DTOOLCONFIG extern void Dtool_PyModuleClassInit_DTOOL_SUPER_BASE(PyObject *module);
|
||||
EXPCL_INTERROGATEDB extern struct Dtool_PyTypedObject Dtool_DTOOL_SUPER_BASE;
|
||||
EXPCL_INTERROGATEDB extern void Dtool_PyModuleClassInit_DTOOL_SUPER_BASE(PyObject *module);
|
||||
|
||||
#define Dtool_Ptr_DTOOL_SUPER_BASE (&Dtool_DTOOL_SUPER_BASE)
|
||||
|
||||
|
||||
@ -2580,14 +2580,18 @@ if (PkgSkip("DIRECT")==0):
|
||||
if sys.platform == 'win32':
|
||||
core_so = GetOutputDir() + '/panda3d/core.pyd'
|
||||
direct_so = GetOutputDir() + '/panda3d/direct.pyd'
|
||||
dtoolconfig_so = GetOutputDir() + '/panda3d/dtoolconfig.pyd'
|
||||
else:
|
||||
core_so = GetOutputDir() + '/panda3d/core.so'
|
||||
direct_so = GetOutputDir() + '/panda3d/direct.so'
|
||||
dtoolconfig_so = GetOutputDir() + '/panda3d/dtoolconfig.so'
|
||||
|
||||
if os.path.isfile(core_so):
|
||||
os.remove(core_so)
|
||||
if os.path.isfile(direct_so):
|
||||
os.remove(direct_so)
|
||||
if os.path.isfile(dtoolconfig_so):
|
||||
os.remove(dtoolconfig_so)
|
||||
|
||||
# Write an appropriate panda3d/__init__.py
|
||||
p3d_init = """"Python bindings for the Panda3D libraries"
|
||||
@ -3124,18 +3128,6 @@ TargetAdd('p3prc_composite2.obj', opts=OPTS, input='p3prc_composite2.cxx')
|
||||
OPTS=['DIR:dtool/src/dconfig', 'BUILDING:DTOOLCONFIG']
|
||||
TargetAdd('p3dconfig_composite1.obj', opts=OPTS, input='p3dconfig_composite1.cxx')
|
||||
|
||||
#
|
||||
# DIRECTORY: dtool/src/interrogatedb/
|
||||
#
|
||||
|
||||
OPTS=['DIR:dtool/src/interrogatedb', 'BUILDING:DTOOLCONFIG']
|
||||
TargetAdd('p3interrogatedb_composite1.obj', opts=OPTS, input='p3interrogatedb_composite1.cxx')
|
||||
TargetAdd('p3interrogatedb_composite2.obj', opts=OPTS, input='p3interrogatedb_composite2.cxx')
|
||||
TargetAdd('libp3interrogatedb.dll', input='p3interrogatedb_composite1.obj')
|
||||
TargetAdd('libp3interrogatedb.dll', input='p3interrogatedb_composite2.obj')
|
||||
TargetAdd('libp3interrogatedb.dll', input='libp3dtool.dll')
|
||||
TargetAdd('libp3interrogatedb.dll', opts=['PYTHON'])
|
||||
|
||||
#
|
||||
# DIRECTORY: dtool/metalibs/dtoolconfig/
|
||||
#
|
||||
@ -3149,14 +3141,32 @@ TargetAdd('libp3dtoolconfig.dll', input='p3prc_composite2.obj')
|
||||
TargetAdd('libp3dtoolconfig.dll', input='libp3dtool.dll')
|
||||
TargetAdd('libp3dtoolconfig.dll', opts=['ADVAPI', 'OPENSSL', 'WINGDI', 'WINUSER'])
|
||||
|
||||
#
|
||||
# DIRECTORY: dtool/src/interrogatedb/
|
||||
#
|
||||
|
||||
OPTS=['DIR:dtool/src/interrogatedb', 'BUILDING:INTERROGATEDB']
|
||||
TargetAdd('p3interrogatedb_composite1.obj', opts=OPTS, input='p3interrogatedb_composite1.cxx')
|
||||
TargetAdd('p3interrogatedb_composite2.obj', opts=OPTS, input='p3interrogatedb_composite2.cxx')
|
||||
TargetAdd('libp3interrogatedb.dll', input='p3interrogatedb_composite1.obj')
|
||||
TargetAdd('libp3interrogatedb.dll', input='p3interrogatedb_composite2.obj')
|
||||
TargetAdd('libp3interrogatedb.dll', input='libp3dtool.dll')
|
||||
TargetAdd('libp3interrogatedb.dll', input='libp3dtoolconfig.dll')
|
||||
TargetAdd('libp3interrogatedb.dll', opts=['PYTHON'])
|
||||
|
||||
if not PkgSkip("PYTHON"):
|
||||
# This used to be called dtoolconfig.pyd, but it just contains the interrogatedb
|
||||
# stuff, so it has been renamed appropriately.
|
||||
OPTS=['DIR:dtool/metalibs/dtoolconfig']
|
||||
TargetAdd('dtoolconfig_pydtool.obj', opts=OPTS, input="pydtool.cxx")
|
||||
TargetAdd('dtoolconfig.pyd', input='dtoolconfig_pydtool.obj')
|
||||
TargetAdd('dtoolconfig.pyd', input='libp3dtoolconfig.dll')
|
||||
TargetAdd('dtoolconfig.pyd', input='libp3dtool.dll')
|
||||
TargetAdd('dtoolconfig.pyd', input='libp3interrogatedb.dll')
|
||||
TargetAdd('dtoolconfig.pyd', opts=['PYTHON'])
|
||||
TargetAdd('interrogatedb_pydtool.obj', opts=OPTS, input="pydtool.cxx")
|
||||
TargetAdd('interrogatedb.pyd', input='interrogatedb_pydtool.obj')
|
||||
TargetAdd('interrogatedb.pyd', input='libp3dtool.dll')
|
||||
TargetAdd('interrogatedb.pyd', input='libp3dtoolconfig.dll')
|
||||
TargetAdd('interrogatedb.pyd', input='libp3interrogatedb.dll')
|
||||
TargetAdd('interrogatedb.pyd', opts=['PYTHON'])
|
||||
|
||||
# Make a stub file importing the new one for backward compatibility.
|
||||
TargetAdd('panda3d/dtoolconfig.py', input='interrogatedb.pyd')
|
||||
|
||||
#
|
||||
# DIRECTORY: dtool/src/pystub/
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user