Panda3D

interrogate_interface.cxx

00001 // Filename: interrogate_interface.cxx
00002 // Created by:  drose (31Jul00)
00003 //
00004 ////////////////////////////////////////////////////////////////////
00005 //
00006 // PANDA 3D SOFTWARE
00007 // Copyright (c) Carnegie Mellon University.  All rights reserved.
00008 //
00009 // All use of this software is subject to the terms of the revised BSD
00010 // license.  You should have received a copy of this license along
00011 // with this source code in a file named "LICENSE."
00012 //
00013 ////////////////////////////////////////////////////////////////////
00014 
00015 #include "interrogate_interface.h"
00016 #include "interrogateDatabase.h"
00017 #include "interrogateType.h"
00018 #include "interrogateFunction.h"
00019 #include "config_interrogatedb.h"
00020 
00021 // This function adds one more directory to the list of directories
00022 // search for interrogate (*.in) files.  In the past, this list has
00023 // been defined the environment variable ETC_PATH, but now it is
00024 // passed in by the code generator.
00025 void 
00026 interrogate_add_search_directory(const char *dirname) {
00027   //cerr << "interrogate_add_search_directory(" << dirname << ")\n";
00028   interrogatedb_path.append_directory(Filename::from_os_specific(dirname));
00029 }
00030 
00031 // This function works similar to the above, but adds a complete path
00032 // string--a list of multiple directories, separated by the standard
00033 // delimiter--to the search path.
00034 void 
00035 interrogate_add_search_path(const char *pathstring) {
00036   //cerr << "interrogate_add_search_path(" << pathstring << ")\n";
00037   interrogatedb_path.append_path(pathstring);
00038 }
00039 
00040 bool interrogate_error_flag() {
00041   //cerr << "interrogate_error_flag\n";
00042   return InterrogateDatabase::get_ptr()->get_error_flag();
00043 }
00044 
00045 int
00046 interrogate_number_of_manifests() {
00047   //cerr << "interrogate_number_of_manifests\n";
00048   return InterrogateDatabase::get_ptr()->get_num_global_manifests();
00049 }
00050 
00051 ManifestIndex
00052 interrogate_get_manifest(int n) {
00053   //cerr << "interrogate_get_manifest(" << n << ")\n";
00054   return InterrogateDatabase::get_ptr()->get_global_manifest(n);
00055 }
00056 
00057 ManifestIndex
00058 interrogate_get_manifest_by_name(const char *manifest_name) {
00059   //cerr << "interrogate_get_manifest_by_name(" << manifest_name << ")\n";
00060   return InterrogateDatabase::get_ptr()->lookup_manifest_by_name(manifest_name);
00061 }
00062 
00063 const char *
00064 interrogate_manifest_name(ManifestIndex manifest) {
00065   //cerr << "interrogate_manifest_name(" << manifest << ")\n";
00066   return InterrogateDatabase::get_ptr()->get_manifest(manifest).get_name().c_str();
00067 }
00068 
00069 const char *
00070 interrogate_manifest_definition(ManifestIndex manifest) {
00071   //cerr << "interrogate_manifest_definition(" << manifest << ")\n";
00072   return InterrogateDatabase::get_ptr()->get_manifest(manifest).get_definition().c_str();
00073 }
00074 
00075 bool
00076 interrogate_manifest_has_type(ManifestIndex manifest) {
00077   //cerr << "interrogate_manifest_has_type(" << manifest << ")\n";
00078   return InterrogateDatabase::get_ptr()->get_manifest(manifest).has_type();
00079 }
00080 
00081 TypeIndex
00082 interrogate_manifest_get_type(ManifestIndex manifest) {
00083   //cerr << "interrogate_manifest_get_type(" << manifest << ")\n";
00084   return InterrogateDatabase::get_ptr()->get_manifest(manifest).get_type();
00085 }
00086 
00087 bool
00088 interrogate_manifest_has_getter(ManifestIndex manifest) {
00089   //cerr << "interrogate_manifest_has_getter(" << manifest << ")\n";
00090   return InterrogateDatabase::get_ptr()->get_manifest(manifest).has_getter();
00091 }
00092 
00093 FunctionIndex
00094 interrogate_manifest_getter(ManifestIndex manifest) {
00095   //cerr << "interrogate_manifest_getter(" << manifest << ")\n";
00096   return InterrogateDatabase::get_ptr()->get_manifest(manifest).get_getter();
00097 }
00098 
00099 bool
00100 interrogate_manifest_has_int_value(ManifestIndex manifest) {
00101   //cerr << "interrogate_manifest_has_int_value(" << manifest << ")\n";
00102   return InterrogateDatabase::get_ptr()->get_manifest(manifest).has_int_value();
00103 }
00104 
00105 int
00106 interrogate_manifest_get_int_value(ManifestIndex manifest) {
00107   //cerr << "interrogate_manifest_get_int_value(" << manifest << ")\n";
00108   return InterrogateDatabase::get_ptr()->get_manifest(manifest).get_int_value();
00109 }
00110 
00111 const char *
00112 interrogate_element_name(ElementIndex element) {
00113   //cerr << "interrogate_element_name(" << element << ")\n";
00114   return InterrogateDatabase::get_ptr()->get_element(element).get_name().c_str();
00115 }
00116 
00117 const char *
00118 interrogate_element_scoped_name(ElementIndex element) {
00119   //cerr << "interrogate_element_scoped_name(" << element << ")\n";
00120   return InterrogateDatabase::get_ptr()->get_element(element).get_scoped_name().c_str();
00121 }
00122 
00123 ElementIndex
00124 interrogate_get_element_by_name(const char *element_name) {
00125   //cerr << "interrogate_get_element_by_name(" << element_name << ")\n";
00126   return InterrogateDatabase::get_ptr()->lookup_element_by_name(element_name);
00127 }
00128 
00129 ElementIndex
00130 interrogate_get_element_by_scoped_name(const char *element_name) {
00131   //cerr << "interrogate_get_element_by_scoped_name(" << element_name << ")\n";
00132   return InterrogateDatabase::get_ptr()->lookup_element_by_scoped_name(element_name);
00133 }
00134 
00135 TypeIndex
00136 interrogate_element_type(ElementIndex element) {
00137   //cerr << "interrogate_element_type(" << element << ")\n";
00138   return InterrogateDatabase::get_ptr()->get_element(element).get_type();
00139 }
00140 
00141 bool
00142 interrogate_element_has_getter(ElementIndex element) {
00143   //cerr << "interrogate_element_has_getter(" << element << ")\n";
00144   return InterrogateDatabase::get_ptr()->get_element(element).has_getter();
00145 }
00146 
00147 FunctionIndex
00148 interrogate_element_getter(ElementIndex element) {
00149   //cerr << "interrogate_element_getter(" << element << ")\n";
00150   return InterrogateDatabase::get_ptr()->get_element(element).get_getter();
00151 }
00152 
00153 bool
00154 interrogate_element_has_setter(ElementIndex element) {
00155   //cerr << "interrogate_element_has_setter(" << element << ")\n";
00156   return InterrogateDatabase::get_ptr()->get_element(element).has_setter();
00157 }
00158 
00159 FunctionIndex
00160 interrogate_element_setter(ElementIndex element) {
00161   //cerr << "interrogate_element_setter(" << element << ")\n";
00162   return InterrogateDatabase::get_ptr()->get_element(element).get_setter();
00163 }
00164 
00165 int
00166 interrogate_number_of_globals() {
00167   //cerr << "interrogate_number_of_globals()\n";
00168   return InterrogateDatabase::get_ptr()->get_num_global_elements();
00169 }
00170 
00171 ElementIndex
00172 interrogate_get_global(int n) {
00173   //cerr << "interrogate_get_global(" << n << ")\n";
00174   return InterrogateDatabase::get_ptr()->get_global_element(n);
00175 }
00176 
00177 int
00178 interrogate_number_of_global_functions() {
00179   //cerr << "interrogate_number_of_global_functions()\n";
00180   return InterrogateDatabase::get_ptr()->get_num_global_functions();
00181 }
00182 
00183 FunctionIndex
00184 interrogate_get_global_function(int n) {
00185   //cerr << "interrogate_get_global_function(" << n << ")\n";
00186   return InterrogateDatabase::get_ptr()->get_global_function(n);
00187 }
00188 
00189 int
00190 interrogate_number_of_functions() {
00191   //cerr << "interrogate_number_of_functions()\n";
00192   return InterrogateDatabase::get_ptr()->get_num_all_functions();
00193 }
00194 
00195 FunctionIndex
00196 interrogate_get_function(int n) {
00197   //cerr << "interrogate_get_function(" << n << ")\n";
00198   return InterrogateDatabase::get_ptr()->get_all_function(n);
00199 }
00200 
00201 const char *
00202 interrogate_function_name(FunctionIndex function) {
00203   //cerr << "interrogate_function_name(" << function << ")\n";
00204   return InterrogateDatabase::get_ptr()->get_function(function).get_name().c_str();
00205 }
00206 
00207 const char *
00208 interrogate_function_scoped_name(FunctionIndex function) {
00209   //cerr << "interrogate_function_scoped_name(" << function << ")\n";
00210   return InterrogateDatabase::get_ptr()->get_function(function).get_scoped_name().c_str();
00211 }
00212 
00213 bool
00214 interrogate_function_has_comment(FunctionIndex function) {
00215   //cerr << "interrogate_function_has_comment(" << function << ")\n";
00216   return InterrogateDatabase::get_ptr()->get_function(function).has_comment();
00217 }
00218 
00219 const char *
00220 interrogate_function_comment(FunctionIndex function) {
00221   //cerr << "interrogate_function_comment(" << function << ")\n";
00222   return InterrogateDatabase::get_ptr()->get_function(function).get_comment().c_str();
00223 }
00224 
00225 const char *
00226 interrogate_function_prototype(FunctionIndex function) {
00227   //cerr << "interrogate_function_prototype(" << function << ")\n";
00228   return InterrogateDatabase::get_ptr()->get_function(function).get_prototype().c_str();
00229 }
00230 
00231 bool
00232 interrogate_function_is_method(FunctionIndex function) {
00233   //cerr << "interrogate_function_is_method(" << function << ")\n";
00234   return InterrogateDatabase::get_ptr()->get_function(function).is_method();
00235 }
00236 
00237 TypeIndex
00238 interrogate_function_class(FunctionIndex function) {
00239   //cerr << "interrogate_function_class(" << function << ")\n";
00240   return InterrogateDatabase::get_ptr()->get_function(function).get_class();
00241 }
00242 
00243 bool
00244 interrogate_function_has_module_name(FunctionIndex function) {
00245   //cerr << "interrogate_function_has_module_name(" << function << ")\n";
00246   return InterrogateDatabase::get_ptr()->get_function(function).has_module_name();
00247 }
00248 
00249 const char *
00250 interrogate_function_module_name(FunctionIndex function) {
00251   //cerr << "interrogate_function_module_name(" << function << ")\n";
00252   return InterrogateDatabase::get_ptr()->get_function(function).get_module_name();
00253 }
00254 
00255 bool
00256 interrogate_function_has_library_name(FunctionIndex function) {
00257   //cerr << "interrogate_function_has_library_name(" << function << ")\n";
00258   return InterrogateDatabase::get_ptr()->get_function(function).has_library_name();
00259 }
00260 
00261 const char *
00262 interrogate_function_library_name(FunctionIndex function) {
00263   //cerr << "interrogate_function_library_name(" << function << ")\n";
00264   return InterrogateDatabase::get_ptr()->get_function(function).get_library_name();
00265 }
00266 
00267 
00268 
00269 bool
00270 interrogate_function_is_virtual(FunctionIndex function) {
00271   //cerr << "interrogate_function_is_virtual(" << function << ")\n";
00272   return InterrogateDatabase::get_ptr()->get_function(function).is_virtual();
00273 }
00274 
00275 int
00276 interrogate_function_number_of_c_wrappers(FunctionIndex function) {
00277   //cerr << "interrogate_function_number_of_c_wrappers(" << function << ")\n";
00278   return InterrogateDatabase::get_ptr()->get_function(function).number_of_c_wrappers();
00279 }
00280 
00281 FunctionWrapperIndex
00282 interrogate_function_c_wrapper(FunctionIndex function, int n) {
00283   //cerr << "interrogate_function_c_wrapper(" << function << ", " << n << ")\n";
00284   return InterrogateDatabase::get_ptr()->get_function(function).get_c_wrapper(n);
00285 }
00286 
00287 int
00288 interrogate_function_number_of_python_wrappers(FunctionIndex function) {
00289   //cerr << "interrogate_function_number_of_python_wrappers(" << function << ")\n";
00290   return InterrogateDatabase::get_ptr()->get_function(function).number_of_python_wrappers();
00291 }
00292 
00293 FunctionWrapperIndex
00294 interrogate_function_python_wrapper(FunctionIndex function, int n) {
00295   //cerr << "interrogate_function_python_wrapper(" << function << ", " << n << ")\n";
00296   return InterrogateDatabase::get_ptr()->get_function(function).get_python_wrapper(n);
00297 }
00298 
00299 const char *
00300 interrogate_wrapper_name(FunctionWrapperIndex wrapper) {
00301   //cerr << "interrogate_wrapper_name(" << wrapper << ")\n";
00302   static string result;
00303   result = InterrogateDatabase::get_ptr()->get_wrapper(wrapper).get_name();
00304   return result.c_str();
00305 }
00306 
00307 bool
00308 interrogate_wrapper_is_callable_by_name(FunctionWrapperIndex wrapper) {
00309   //cerr << "interrogate_wrapper_is_callable_by_name(" << wrapper << ")\n";
00310   return InterrogateDatabase::get_ptr()->get_wrapper(wrapper).is_callable_by_name();
00311 }
00312 
00313 bool
00314 interrogate_wrapper_has_comment(FunctionWrapperIndex wrapper) {
00315   //cerr << "interrogate_wrapper_has_comment(" << wrapper << ")\n";
00316   return InterrogateDatabase::get_ptr()->get_wrapper(wrapper).has_comment();
00317 }
00318 
00319 const char *
00320 interrogate_wrapper_comment(FunctionWrapperIndex wrapper) {
00321   //cerr << "interrogate_wrapper_comment(" << wrapper << ")\n";
00322   return InterrogateDatabase::get_ptr()->get_wrapper(wrapper).get_comment().c_str();
00323 }
00324 
00325 bool
00326 interrogate_wrapper_has_return_value(FunctionWrapperIndex wrapper) {
00327   //cerr << "interrogate_wrapper_has_return_value(" << wrapper << ")\n";
00328   return InterrogateDatabase::get_ptr()->get_wrapper(wrapper).has_return_value();
00329 }
00330 
00331 TypeIndex
00332 interrogate_wrapper_return_type(FunctionWrapperIndex wrapper) {
00333   //cerr << "interrogate_wrapper_return_type(" << wrapper << ")\n";
00334   return InterrogateDatabase::get_ptr()->get_wrapper(wrapper).get_return_type();
00335 }
00336 
00337 bool
00338 interrogate_wrapper_caller_manages_return_value(FunctionWrapperIndex wrapper) {
00339   //cerr << "interrogate_wrapper_caller_manages_return_value(" << wrapper << ")\n";
00340   return InterrogateDatabase::get_ptr()->get_wrapper(wrapper).caller_manages_return_value();
00341 }
00342 
00343 FunctionIndex
00344 interrogate_wrapper_return_value_destructor(FunctionWrapperIndex wrapper) {
00345   //cerr << "interrogate_wrapper_return_value_destructor(" << wrapper << ")\n";
00346   return InterrogateDatabase::get_ptr()->get_wrapper(wrapper).get_return_value_destructor();
00347 }
00348 
00349 int
00350 interrogate_wrapper_number_of_parameters(FunctionWrapperIndex wrapper) {
00351   //cerr << "interrogate_wrapper_number_of_parameters(" << wrapper << ")\n";
00352   return InterrogateDatabase::get_ptr()->get_wrapper(wrapper).number_of_parameters();
00353 }
00354 
00355 TypeIndex
00356 interrogate_wrapper_parameter_type(FunctionWrapperIndex wrapper, int n) {
00357   //cerr << "interrogate_wrapper_parameter_type(" << wrapper << ", " << n << ")\n";
00358   return InterrogateDatabase::get_ptr()->get_wrapper(wrapper).parameter_get_type(n);
00359 }
00360 
00361 bool
00362 interrogate_wrapper_parameter_has_name(FunctionWrapperIndex wrapper, int n) {
00363   //cerr << "interrogate_wrapper_parameter_has_name(" << wrapper << ", " << n << ")\n";
00364   return InterrogateDatabase::get_ptr()->get_wrapper(wrapper).parameter_has_name(n);
00365 }
00366 
00367 const char *
00368 interrogate_wrapper_parameter_name(FunctionWrapperIndex wrapper, int n) {
00369   //cerr << "interrogate_wrapper_parameter_name(" << wrapper << ", " << n << ")\n";
00370   return InterrogateDatabase::get_ptr()->get_wrapper(wrapper).parameter_get_name(n).c_str();
00371 }
00372 
00373 bool
00374 interrogate_wrapper_parameter_is_this(FunctionWrapperIndex wrapper, int n) {
00375   //cerr << "interrogate_wrapper_is_this(" << wrapper << ", " << n << ")\n";
00376   return InterrogateDatabase::get_ptr()->get_wrapper(wrapper).parameter_is_this(n);
00377 }
00378 
00379 bool
00380 interrogate_wrapper_has_pointer(FunctionWrapperIndex wrapper) {
00381   //cerr << "interrogate_wrapper_has_pointer(" << wrapper << ")\n";
00382   return (InterrogateDatabase::get_ptr()->get_fptr(wrapper) != (void *)NULL);
00383 }
00384 
00385 void *
00386 interrogate_wrapper_pointer(FunctionWrapperIndex wrapper) {
00387   //cerr << "interrogate_wrapper_pointer(" << wrapper << ")\n";
00388   return InterrogateDatabase::get_ptr()->get_fptr(wrapper);
00389 }
00390 
00391 const char *
00392 interrogate_wrapper_unique_name(FunctionWrapperIndex wrapper) {
00393   //cerr << "interrogate_wrapper_unique_name(" << wrapper << ")\n";
00394   static string result;
00395   result = InterrogateDatabase::get_ptr()->get_wrapper(wrapper).get_unique_name();
00396   return result.c_str();
00397 }
00398 
00399 FunctionWrapperIndex
00400 interrogate_get_wrapper_by_unique_name(const char *unique_name) {
00401   //cerr << "interrogate_get_wrapper_by_unique_name(" << unique_name << ")\n";
00402   return InterrogateDatabase::get_ptr()->get_wrapper_by_unique_name(unique_name);
00403 }
00404 
00405 TypeIndex 
00406 interrogate_make_seq_class(MakeSeqIndex make_seq) {
00407   //cerr << "interrogate_make_seq_class(" << make_seq << ")\n";
00408   return InterrogateDatabase::get_ptr()->get_make_seq(make_seq).get_class();
00409 }
00410 
00411 const char *
00412 interrogate_make_seq_seq_name(MakeSeqIndex make_seq) {
00413   //cerr << "interrogate_make_seq_seq_name(" << make_seq << ")\n";
00414   static string result;
00415   result = InterrogateDatabase::get_ptr()->get_make_seq(make_seq).get_seq_name();
00416   return result.c_str();
00417 }
00418 
00419 const char *
00420 interrogate_make_seq_num_name(MakeSeqIndex make_seq) {
00421   //cerr << "interrogate_make_seq_num_name(" << make_seq << ")\n";
00422   static string result;
00423   result = InterrogateDatabase::get_ptr()->get_make_seq(make_seq).get_num_name();
00424   return result.c_str();
00425 }
00426 
00427 const char *
00428 interrogate_make_seq_element_name(MakeSeqIndex make_seq) {
00429   //cerr << "interrogate_make_seq_element_name(" << make_seq << ")\n";
00430   static string result;
00431   result = InterrogateDatabase::get_ptr()->get_make_seq(make_seq).get_element_name();
00432   return result.c_str();
00433 }
00434 
00435 int
00436 interrogate_number_of_global_types() {
00437   //cerr << "interrogate_number_of_global_types()\n";
00438   return InterrogateDatabase::get_ptr()->get_num_global_types();
00439 }
00440 
00441 TypeIndex
00442 interrogate_get_global_type(int n) {
00443   //cerr << "interrogate_get_global_type(" << n << ")\n";
00444   return InterrogateDatabase::get_ptr()->get_global_type(n);
00445 }
00446 
00447 int
00448 interrogate_number_of_types() {
00449   //cerr << "interrogate_number_of_types()\n";
00450   return InterrogateDatabase::get_ptr()->get_num_all_types();
00451 }
00452 
00453 TypeIndex
00454 interrogate_get_type(int n) {
00455   //cerr << "interrogate_get_type(" << n << ")\n";
00456   return InterrogateDatabase::get_ptr()->get_all_type(n);
00457 }
00458 
00459 TypeIndex
00460 interrogate_get_type_by_name(const char *type_name) {
00461   //cerr << "interrogate_get_type_by_name(" << type_name << ")\n";
00462   return InterrogateDatabase::get_ptr()->lookup_type_by_name(type_name);
00463 }
00464 
00465 TypeIndex
00466 interrogate_get_type_by_scoped_name(const char *type_name) {
00467   //cerr << "interrogate_get_type_by_scoped_name(" << type_name << ")\n";
00468   return InterrogateDatabase::get_ptr()->lookup_type_by_scoped_name(type_name);
00469 }
00470 
00471 TypeIndex
00472 interrogate_get_type_by_true_name(const char *type_name) {
00473   //cerr << "interrogate_get_type_by_true_name(" << type_name << ")\n";
00474   return InterrogateDatabase::get_ptr()->lookup_type_by_true_name(type_name);
00475 }
00476 
00477 const char *
00478 interrogate_type_name(TypeIndex type) {
00479   //cerr << "interrogate_type_name(" << type << ")\n";
00480   return InterrogateDatabase::get_ptr()->get_type(type).get_name().c_str();
00481 }
00482 
00483 const char *
00484 interrogate_type_scoped_name(TypeIndex type) {
00485   //cerr << "interrogate_type_scoped_name(" << type << ")\n";
00486   return InterrogateDatabase::get_ptr()->get_type(type).get_scoped_name().c_str();
00487 }
00488 
00489 const char *
00490 interrogate_type_true_name(TypeIndex type) {
00491   //cerr << "interrogate_type_true_name(" << type << ")\n";
00492   return InterrogateDatabase::get_ptr()->get_type(type).get_true_name().c_str();
00493 }
00494 
00495 bool
00496 interrogate_type_is_nested(TypeIndex type) {
00497   //cerr << "interrogate_type_is_nested(" << type << ")\n";
00498   return InterrogateDatabase::get_ptr()->get_type(type).is_nested();
00499 }
00500 
00501 TypeIndex
00502 interrogate_type_outer_class(TypeIndex type) {
00503   //cerr << "interrogate_type_outer_class(" << type << ")\n";
00504   return InterrogateDatabase::get_ptr()->get_type(type).get_outer_class();
00505 }
00506 
00507 bool
00508 interrogate_type_has_comment(TypeIndex type) {
00509   //cerr << "interrogate_type_has_comment(" << type << ")\n";
00510   return InterrogateDatabase::get_ptr()->get_type(type).has_comment();
00511 }
00512 
00513 const char *
00514 interrogate_type_comment(TypeIndex type) {
00515   //cerr << "interrogate_type_comment(" << type << ")\n";
00516   return InterrogateDatabase::get_ptr()->get_type(type).get_comment().c_str();
00517 }
00518 
00519 bool
00520 interrogate_type_has_module_name(TypeIndex type) {
00521   //cerr << "interrogate_type_has_module_name(" << type << ")\n";
00522   return InterrogateDatabase::get_ptr()->get_type(type).has_module_name();
00523 }
00524 
00525 const char *
00526 interrogate_type_module_name(TypeIndex type) {
00527   //cerr << "interrogate_type_module_name(" << type << ")\n";
00528   return InterrogateDatabase::get_ptr()->get_type(type).get_module_name();
00529 }
00530 
00531 bool
00532 interrogate_type_has_library_name(TypeIndex type) {
00533   //cerr << "interrogate_type_has_library_name(" << type << ")\n";
00534   return InterrogateDatabase::get_ptr()->get_type(type).has_library_name();
00535 }
00536 
00537 const char *
00538 interrogate_type_library_name(TypeIndex type) {
00539   //cerr << "interrogate_type_library_name(" << type << ")\n";
00540   return InterrogateDatabase::get_ptr()->get_type(type).get_library_name();
00541 }
00542 
00543 
00544 bool
00545 interrogate_type_is_atomic(TypeIndex type) {
00546   //cerr << "interrogate_type_is_atomic(" << type << ")\n";
00547   return InterrogateDatabase::get_ptr()->get_type(type).is_atomic();
00548 }
00549 
00550 AtomicToken
00551 interrogate_type_atomic_token(TypeIndex type) {
00552   //cerr << "interrogate_type_atomic_token(" << type << ")\n";
00553   return InterrogateDatabase::get_ptr()->get_type(type).get_atomic_token();
00554 }
00555 
00556 bool
00557 interrogate_type_is_unsigned(TypeIndex type) {
00558   //cerr << "interrogate_type_is_unsigned(" << type << ")\n";
00559   return InterrogateDatabase::get_ptr()->get_type(type).is_unsigned();
00560 }
00561 
00562 bool
00563 interrogate_type_is_signed(TypeIndex type) {
00564   //cerr << "interrogate_type_is_signed(" << type << ")\n";
00565   return InterrogateDatabase::get_ptr()->get_type(type).is_signed();
00566 }
00567 
00568 bool
00569 interrogate_type_is_long(TypeIndex type) {
00570   //cerr << "interrogate_type_is_long(" << type << ")\n";
00571   return InterrogateDatabase::get_ptr()->get_type(type).is_long();
00572 }
00573 
00574 bool
00575 interrogate_type_is_longlong(TypeIndex type) {
00576   //cerr << "interrogate_type_is_longlong(" << type << ")\n";
00577   return InterrogateDatabase::get_ptr()->get_type(type).is_longlong();
00578 }
00579 
00580 bool
00581 interrogate_type_is_short(TypeIndex type) {
00582   //cerr << "interrogate_type_is_short(" << type << ")\n";
00583   return InterrogateDatabase::get_ptr()->get_type(type).is_short();
00584 }
00585 
00586 bool
00587 interrogate_type_is_wrapped(TypeIndex type) {
00588   //cerr << "interrogate_type_is_wrapped(" << type << ")\n";
00589   return InterrogateDatabase::get_ptr()->get_type(type).is_wrapped();
00590 }
00591 
00592 bool
00593 interrogate_type_is_pointer(TypeIndex type) {
00594   //cerr << "interrogate_type_is_pointer(" << type << ")\n";
00595   return InterrogateDatabase::get_ptr()->get_type(type).is_pointer();
00596 }
00597 
00598 bool
00599 interrogate_type_is_const(TypeIndex type) {
00600   //cerr << "interrogate_type_is_const(" << type << ")\n";
00601   return InterrogateDatabase::get_ptr()->get_type(type).is_const();
00602 }
00603 
00604 TypeIndex
00605 interrogate_type_wrapped_type(TypeIndex type) {
00606   //cerr << "interrogate_type_wrapped_type(" << type << ")\n";
00607   return InterrogateDatabase::get_ptr()->get_type(type).get_wrapped_type();
00608 }
00609 
00610 bool
00611 interrogate_type_is_enum(TypeIndex type) {
00612   //cerr << "interrogate_type_is_enum(" << type << ")\n";
00613   return InterrogateDatabase::get_ptr()->get_type(type).is_enum();
00614 }
00615 
00616 int
00617 interrogate_type_number_of_enum_values(TypeIndex type) {
00618   //cerr << "interrogate_type_number_of_enum_values(" << type << ")\n";
00619   return InterrogateDatabase::get_ptr()->get_type(type).number_of_enum_values();
00620 }
00621 
00622 const char *
00623 interrogate_type_enum_value_name(TypeIndex type, int n) {
00624   //cerr << "interrogate_type_enum_value_name(" << type << ", " << n << ")\n";
00625   return InterrogateDatabase::get_ptr()->get_type(type).get_enum_value_name(n).c_str();
00626 }
00627 
00628 const char *
00629 interrogate_type_enum_value_scoped_name(TypeIndex type, int n) {
00630   //cerr << "interrogate_type_enum_value_scoped_name(" << type << ", " << n << ")\n";
00631   return InterrogateDatabase::get_ptr()->get_type(type).get_enum_value_scoped_name(n).c_str();
00632 }
00633 
00634 int
00635 interrogate_type_enum_value(TypeIndex type, int n) {
00636   //cerr << "interrogate_type_enum_value(" << type << ", " << n << ")\n";
00637   return InterrogateDatabase::get_ptr()->get_type(type).get_enum_value(n);
00638 }
00639 
00640 bool
00641 interrogate_type_is_struct(TypeIndex type) {
00642   //cerr << "interrogate_type_is_struct(" << type << ")\n";
00643   return InterrogateDatabase::get_ptr()->get_type(type).is_struct();
00644 }
00645 
00646 bool
00647 interrogate_type_is_class(TypeIndex type) {
00648   //cerr << "interrogate_type_is_class(" << type << ")\n";
00649   return InterrogateDatabase::get_ptr()->get_type(type).is_class();
00650 }
00651 
00652 bool
00653 interrogate_type_is_union(TypeIndex type) {
00654   //cerr << "interrogate_type_is_union(" << type << ")\n";
00655   return InterrogateDatabase::get_ptr()->get_type(type).is_union();
00656 }
00657 
00658 bool
00659 interrogate_type_is_fully_defined(TypeIndex type) {
00660   //cerr << "interrogate_type_is_fully_defined(" << type << ")\n";
00661   return InterrogateDatabase::get_ptr()->get_type(type).is_fully_defined();
00662 }
00663 
00664 bool
00665 interrogate_type_is_unpublished(TypeIndex type) {
00666   //cerr << "interrogate_type_is_unpublished(" << type << ")\n";
00667   return InterrogateDatabase::get_ptr()->get_type(type).is_unpublished();
00668 }
00669 
00670 int
00671 interrogate_type_number_of_constructors(TypeIndex type) {
00672   //cerr << "interrogate_type_number_of_constructors(" << type << ")\n";
00673   return InterrogateDatabase::get_ptr()->get_type(type).number_of_constructors();
00674 }
00675 
00676 FunctionIndex
00677 interrogate_type_get_constructor(TypeIndex type, int n) {
00678   //cerr << "interrogate_type_get_constructor(" << type << ", " << n << ")\n";
00679   return InterrogateDatabase::get_ptr()->get_type(type).get_constructor(n);
00680 }
00681 
00682 bool
00683 interrogate_type_has_destructor(TypeIndex type) {
00684   //cerr << "interrogate_type_has_destructor(" << type << ")\n";
00685   return InterrogateDatabase::get_ptr()->get_type(type).has_destructor();
00686 }
00687 
00688 bool
00689 interrogate_type_destructor_is_inherited(TypeIndex type) {
00690   //cerr << "interrogate_type_destructor_is_inherited(" << type << ")\n";
00691   return InterrogateDatabase::get_ptr()->get_type(type).destructor_is_inherited();
00692 }
00693 
00694 FunctionIndex
00695 interrogate_type_get_destructor(TypeIndex type) {
00696   //cerr << "interrogate_type_get_destructor(" << type << ")\n";
00697   return InterrogateDatabase::get_ptr()->get_type(type).get_destructor();
00698 }
00699 
00700 int
00701 interrogate_type_number_of_elements(TypeIndex type) {
00702   //cerr << "interrogate_type_number_of_elements(" << type << ")\n";
00703   return InterrogateDatabase::get_ptr()->get_type(type).number_of_elements();
00704 }
00705 
00706 ElementIndex
00707 interrogate_type_get_element(TypeIndex type, int n) {
00708   //cerr << "interrogate_type_get_element(" << type << ", " << n << ")\n";
00709   return InterrogateDatabase::get_ptr()->get_type(type).get_element(n);
00710 }
00711 
00712 int
00713 interrogate_type_number_of_methods(TypeIndex type) {
00714   //cerr << "interrogate_type_number_of_methods(" << type << ")\n";
00715   return InterrogateDatabase::get_ptr()->get_type(type).number_of_methods();
00716 }
00717 
00718 FunctionIndex
00719 interrogate_type_get_method(TypeIndex type, int n) {
00720   //cerr << "interrogate_type_get_method(" << type << ", " << n << ")\n";
00721   return InterrogateDatabase::get_ptr()->get_type(type).get_method(n);
00722 }
00723 
00724 int
00725 interrogate_type_number_of_make_seqs(TypeIndex type) {
00726   //cerr << "interrogate_type_number_of_make_seqs(" << type << ")\n";
00727   return InterrogateDatabase::get_ptr()->get_type(type).number_of_make_seqs();
00728 }
00729 
00730 MakeSeqIndex
00731 interrogate_type_get_make_seq(TypeIndex type, int n) {
00732   //cerr << "interrogate_type_get_make_seq(" << type << ", " << n << ")\n";
00733   return InterrogateDatabase::get_ptr()->get_type(type).get_make_seq(n);
00734 }
00735 
00736 int
00737 interrogate_type_number_of_casts(TypeIndex type) {
00738   //cerr << "interrogate_type_number_of_casts(" << type << ")\n";
00739   return InterrogateDatabase::get_ptr()->get_type(type).number_of_casts();
00740 }
00741 
00742 FunctionIndex
00743 interrogate_type_get_cast(TypeIndex type, int n) {
00744   //cerr << "interrogate_type_get_cast(" << type << ", " << n << ")\n";
00745   return InterrogateDatabase::get_ptr()->get_type(type).get_cast(n);
00746 }
00747 
00748 int
00749 interrogate_type_number_of_derivations(TypeIndex type) {
00750   //cerr << "interrogate_type_number_of_derivations(" << type << ")\n";
00751   return InterrogateDatabase::get_ptr()->get_type(type).number_of_derivations();
00752 }
00753 
00754 TypeIndex
00755 interrogate_type_get_derivation(TypeIndex type, int n) {
00756   //cerr << "interrogate_type_get_derivation(" << type << ", " << n << ")\n";
00757   return InterrogateDatabase::get_ptr()->get_type(type).get_derivation(n);
00758 }
00759 
00760 bool
00761 interrogate_type_derivation_has_upcast(TypeIndex type, int n) {
00762   //cerr << "interrogate_type_derivation_has_upcast(" << type << ", " << n << ")\n";
00763   return InterrogateDatabase::get_ptr()->get_type(type).derivation_has_upcast(n);
00764 }
00765 
00766 FunctionIndex
00767 interrogate_type_get_upcast(TypeIndex type, int n) {
00768   //cerr << "interrogate_type_get_upcast(" << type << ", " << n << ")\n";
00769   return InterrogateDatabase::get_ptr()->get_type(type).derivation_get_upcast(n);
00770 }
00771 
00772 bool
00773 interrogate_type_derivation_downcast_is_impossible(TypeIndex type, int n) {
00774   //cerr << "interrogate_type_derivation_downcast_is_impossible(" << type << ", " << n << ")\n";
00775   return InterrogateDatabase::get_ptr()->get_type(type).derivation_downcast_is_impossible(n);
00776 }
00777 
00778 bool
00779 interrogate_type_derivation_has_downcast(TypeIndex type, int n) {
00780   //cerr << "interrogate_type_derivation_has_downcast(" << type << ", " << n << ")\n";
00781   return InterrogateDatabase::get_ptr()->get_type(type).derivation_has_downcast(n);
00782 }
00783 
00784 FunctionIndex
00785 interrogate_type_get_downcast(TypeIndex type, int n) {
00786   //cerr << "interrogate_type_get_downcast(" << type << ", " << n << ")\n";
00787   return InterrogateDatabase::get_ptr()->get_type(type).derivation_get_downcast(n);
00788 }
00789 
00790 int
00791 interrogate_type_number_of_nested_types(TypeIndex type) {
00792   //cerr << "interrogate_type_number_of_nested_types(" << type << ")\n";
00793   return InterrogateDatabase::get_ptr()->get_type(type).number_of_nested_types();
00794 }
00795 
00796 TypeIndex
00797 interrogate_type_get_nested_type(TypeIndex type, int n) {
00798   //cerr << "interrogate_type_get_nested_type(" << type << ", " << n << ")\n";
00799   return InterrogateDatabase::get_ptr()->get_type(type).get_nested_type(n);
00800 }
 All Classes Functions Variables Enumerations