From dd17fd864b40bd0fce781adc3baa79f78c6f6565 Mon Sep 17 00:00:00 2001 From: rdb Date: Tue, 30 Jun 2015 16:16:35 +0200 Subject: [PATCH] Properly separate dtoolconfig and interrogatedb --- dtool/metalibs/dtoolconfig/pydtool.cxx | 11 +- dtool/src/dtoolbase/dtoolsymbols.h | 8 + .../src/dtoolutil/p3dtoolutil_composite2.cxx | 1 + .../vector_int.cxx | 4 +- .../{interrogatedb => dtoolutil}/vector_int.h | 4 +- .../src/interrogatedb/config_interrogatedb.h | 2 +- dtool/src/interrogatedb/dtool_super_base.cxx | 2 +- dtool/src/interrogatedb/extension.h | 4 +- dtool/src/interrogatedb/indexRemapper.h | 2 +- .../src/interrogatedb/interrogateComponent.h | 2 +- dtool/src/interrogatedb/interrogateDatabase.h | 2 +- dtool/src/interrogatedb/interrogateElement.h | 2 +- dtool/src/interrogatedb/interrogateFunction.h | 2 +- .../interrogateFunctionWrapper.h | 2 +- dtool/src/interrogatedb/interrogateMakeSeq.h | 2 +- dtool/src/interrogatedb/interrogateManifest.h | 2 +- dtool/src/interrogatedb/interrogateType.h | 2 +- .../src/interrogatedb/interrogate_interface.h | 262 +++++++++--------- dtool/src/interrogatedb/interrogate_request.h | 4 +- .../p3interrogatedb_composite2.cxx | 1 - dtool/src/interrogatedb/py_panda.cxx | 2 +- dtool/src/interrogatedb/py_panda.h | 78 +++--- makepanda/makepanda.py | 46 +-- 23 files changed, 233 insertions(+), 214 deletions(-) rename dtool/src/{interrogatedb => dtoolutil}/vector_int.cxx (91%) rename dtool/src/{interrogatedb => dtoolutil}/vector_int.h (95%) diff --git a/dtool/metalibs/dtoolconfig/pydtool.cxx b/dtool/metalibs/dtoolconfig/pydtool.cxx index 7b3a017b34..bde03f4197 100644 --- a/dtool/metalibs/dtoolconfig/pydtool.cxx +++ b/dtool/metalibs/dtoolconfig/pydtool.cxx @@ -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 } - diff --git a/dtool/src/dtoolbase/dtoolsymbols.h b/dtool/src/dtoolbase/dtoolsymbols.h index 02e976b936..cb4cd7993e 100644 --- a/dtool/src/dtoolbase/dtoolsymbols.h +++ b/dtool/src/dtoolbase/dtoolsymbols.h @@ -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 diff --git a/dtool/src/dtoolutil/p3dtoolutil_composite2.cxx b/dtool/src/dtoolutil/p3dtoolutil_composite2.cxx index 289ce8f1e9..2adf532173 100644 --- a/dtool/src/dtoolutil/p3dtoolutil_composite2.cxx +++ b/dtool/src/dtoolutil/p3dtoolutil_composite2.cxx @@ -8,5 +8,6 @@ #include "stringDecoder.cxx" #include "textEncoder.cxx" #include "unicodeLatinMap.cxx" +#include "vector_int.cxx" #include "vector_string.cxx" #include "win32ArgParser.cxx" diff --git a/dtool/src/interrogatedb/vector_int.cxx b/dtool/src/dtoolutil/vector_int.cxx similarity index 91% rename from dtool/src/interrogatedb/vector_int.cxx rename to dtool/src/dtoolutil/vector_int.cxx index 6e829fcd63..4ec1769281 100644 --- a/dtool/src/interrogatedb/vector_int.cxx +++ b/dtool/src/dtoolutil/vector_int.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 diff --git a/dtool/src/interrogatedb/vector_int.h b/dtool/src/dtoolutil/vector_int.h similarity index 95% rename from dtool/src/interrogatedb/vector_int.h rename to dtool/src/dtoolutil/vector_int.h index 65ee50a4a5..af0a7dd981 100644 --- a/dtool/src/interrogatedb/vector_int.h +++ b/dtool/src/dtoolutil/vector_int.h @@ -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 diff --git a/dtool/src/interrogatedb/config_interrogatedb.h b/dtool/src/interrogatedb/config_interrogatedb.h index e088787b9d..6dd0995532 100644 --- a/dtool/src/interrogatedb/config_interrogatedb.h +++ b/dtool/src/interrogatedb/config_interrogatedb.h @@ -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; diff --git a/dtool/src/interrogatedb/dtool_super_base.cxx b/dtool/src/interrogatedb/dtool_super_base.cxx index 84334cf4c8..7cdcd21221 100644 --- a/dtool/src/interrogatedb/dtool_super_base.cxx +++ b/dtool/src/interrogatedb/dtool_super_base.cxx @@ -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) { diff --git a/dtool/src/interrogatedb/extension.h b/dtool/src/interrogatedb/extension.h index 0d41ef2c60..57728f98bf 100644 --- a/dtool/src/interrogatedb/extension.h +++ b/dtool/src/interrogatedb/extension.h @@ -24,7 +24,7 @@ // be used from the extension method. //////////////////////////////////////////////////////////////////// template -class EXPCL_DTOOLCONFIG ExtensionBase { +class EXPCL_INTERROGATEDB ExtensionBase { public: T * _this; }; @@ -36,7 +36,7 @@ public: // a specialization of this class template. //////////////////////////////////////////////////////////////////// template -class EXPCL_DTOOLCONFIG Extension : public ExtensionBase { +class EXPCL_INTERROGATEDB Extension : public ExtensionBase { }; //////////////////////////////////////////////////////////////////// diff --git a/dtool/src/interrogatedb/indexRemapper.h b/dtool/src/interrogatedb/indexRemapper.h index da2efc023f..61aa67ccc5 100644 --- a/dtool/src/interrogatedb/indexRemapper.h +++ b/dtool/src/interrogatedb/indexRemapper.h @@ -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(); diff --git a/dtool/src/interrogatedb/interrogateComponent.h b/dtool/src/interrogatedb/interrogateComponent.h index 6ad6bcd806..e1820806d3 100644 --- a/dtool/src/interrogatedb/interrogateComponent.h +++ b/dtool/src/interrogatedb/interrogateComponent.h @@ -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 ©); diff --git a/dtool/src/interrogatedb/interrogateDatabase.h b/dtool/src/interrogatedb/interrogateDatabase.h index 8a6a313802..893fa23ba4 100644 --- a/dtool/src/interrogatedb/interrogateDatabase.h +++ b/dtool/src/interrogatedb/interrogateDatabase.h @@ -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(); diff --git a/dtool/src/interrogatedb/interrogateElement.h b/dtool/src/interrogatedb/interrogateElement.h index 863e502545..52d4f25b28 100644 --- a/dtool/src/interrogatedb/interrogateElement.h +++ b/dtool/src/interrogatedb/interrogateElement.h @@ -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 ©); diff --git a/dtool/src/interrogatedb/interrogateFunction.h b/dtool/src/interrogatedb/interrogateFunction.h index 676eb53cf7..04132814f8 100644 --- a/dtool/src/interrogatedb/interrogateFunction.h +++ b/dtool/src/interrogatedb/interrogateFunction.h @@ -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 ©); diff --git a/dtool/src/interrogatedb/interrogateFunctionWrapper.h b/dtool/src/interrogatedb/interrogateFunctionWrapper.h index 4eeae4d600..282b989961 100644 --- a/dtool/src/interrogatedb/interrogateFunctionWrapper.h +++ b/dtool/src/interrogatedb/interrogateFunctionWrapper.h @@ -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 ©); diff --git a/dtool/src/interrogatedb/interrogateMakeSeq.h b/dtool/src/interrogatedb/interrogateMakeSeq.h index 5ce472d4bf..bd991f71ca 100644 --- a/dtool/src/interrogatedb/interrogateMakeSeq.h +++ b/dtool/src/interrogatedb/interrogateMakeSeq.h @@ -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 ©); diff --git a/dtool/src/interrogatedb/interrogateManifest.h b/dtool/src/interrogatedb/interrogateManifest.h index d6d5d00192..4011868953 100644 --- a/dtool/src/interrogatedb/interrogateManifest.h +++ b/dtool/src/interrogatedb/interrogateManifest.h @@ -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 ©); diff --git a/dtool/src/interrogatedb/interrogateType.h b/dtool/src/interrogatedb/interrogateType.h index 365c2a2d40..5a6a88b311 100644 --- a/dtool/src/interrogatedb/interrogateType.h +++ b/dtool/src/interrogatedb/interrogateType.h @@ -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 ©); diff --git a/dtool/src/interrogatedb/interrogate_interface.h b/dtool/src/interrogatedb/interrogate_interface.h index c1e615556f..9cbe879339 100644 --- a/dtool/src/interrogatedb/interrogate_interface.h +++ b/dtool/src/interrogatedb/interrogate_interface.h @@ -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 } diff --git a/dtool/src/interrogatedb/interrogate_request.h b/dtool/src/interrogatedb/interrogate_request.h index 063b04f2ec..06d8bfb1a4 100644 --- a/dtool/src/interrogatedb/interrogate_request.h +++ b/dtool/src/interrogatedb/interrogate_request.h @@ -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 } diff --git a/dtool/src/interrogatedb/p3interrogatedb_composite2.cxx b/dtool/src/interrogatedb/p3interrogatedb_composite2.cxx index e56075e2d0..c6b6c61362 100644 --- a/dtool/src/interrogatedb/p3interrogatedb_composite2.cxx +++ b/dtool/src/interrogatedb/p3interrogatedb_composite2.cxx @@ -5,7 +5,6 @@ #include "interrogate_interface.cxx" #include "interrogate_request.cxx" #include "py_panda.cxx" -#include "vector_int.cxx" diff --git a/dtool/src/interrogatedb/py_panda.cxx b/dtool/src/interrogatedb/py_panda.cxx index 755f0760e6..0278a84ce1 100644 --- a/dtool/src/interrogatedb/py_panda.cxx +++ b/dtool/src/interrogatedb/py_panda.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); diff --git a/dtool/src/interrogatedb/py_panda.h b/dtool/src/interrogatedb/py_panda.h index 5a78786aa4..d7bd7b7ca5 100644 --- a/dtool/src/interrogatedb/py_panda.h +++ b/dtool/src/interrogatedb/py_panda.h @@ -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 INLINE bool DTOOL_Call_ExtractThisPointer(PyObject *self, T *&into) { @@ -338,15 +338,15 @@ template 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 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) diff --git a/makepanda/makepanda.py b/makepanda/makepanda.py index c434c97c89..25af974fcb 100755 --- a/makepanda/makepanda.py +++ b/makepanda/makepanda.py @@ -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/