Panda3D
|
00001 // Filename: interrogateType.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 "interrogateType.h" 00016 #include "indexRemapper.h" 00017 #include "interrogate_datafile.h" 00018 00019 #include <algorithm> 00020 00021 //////////////////////////////////////////////////////////////////// 00022 // Function: InterrogateType::Constructor 00023 // Access: Public 00024 // Description: 00025 //////////////////////////////////////////////////////////////////// 00026 InterrogateType:: 00027 InterrogateType(InterrogateModuleDef *def) : 00028 InterrogateComponent(def) 00029 { 00030 _flags = 0; 00031 _outer_class = 0; 00032 _atomic_token = AT_not_atomic; 00033 _wrapped_type = 0; 00034 _destructor = 0; 00035 00036 _cpptype = (CPPType *)NULL; 00037 _cppscope = (CPPScope *)NULL; 00038 } 00039 00040 //////////////////////////////////////////////////////////////////// 00041 // Function: InterrogateType::Copy Constructor 00042 // Access: Public 00043 // Description: 00044 //////////////////////////////////////////////////////////////////// 00045 InterrogateType:: 00046 InterrogateType(const InterrogateType ©) { 00047 (*this) = copy; 00048 } 00049 00050 //////////////////////////////////////////////////////////////////// 00051 // Function: InterrogateType::Derivation::output 00052 // Access: Public 00053 // Description: 00054 //////////////////////////////////////////////////////////////////// 00055 void InterrogateType::Derivation:: 00056 output(ostream &out) const { 00057 out << _flags << " " << _base << " " << _upcast << " " << _downcast; 00058 } 00059 00060 //////////////////////////////////////////////////////////////////// 00061 // Function: InterrogateType::Derivation::input 00062 // Access: Public 00063 // Description: 00064 //////////////////////////////////////////////////////////////////// 00065 void InterrogateType::Derivation:: 00066 input(istream &in) { 00067 in >> _flags >> _base >> _upcast >> _downcast; 00068 } 00069 00070 //////////////////////////////////////////////////////////////////// 00071 // Function: InterrogateType::EnumValue::output 00072 // Access: Public 00073 // Description: 00074 //////////////////////////////////////////////////////////////////// 00075 void InterrogateType::EnumValue:: 00076 output(ostream &out) const { 00077 idf_output_string(out, _name); 00078 idf_output_string(out, _scoped_name); 00079 out << _value; 00080 } 00081 00082 //////////////////////////////////////////////////////////////////// 00083 // Function: InterrogateType::EnumValue::input 00084 // Access: Public 00085 // Description: 00086 //////////////////////////////////////////////////////////////////// 00087 void InterrogateType::EnumValue:: 00088 input(istream &in) { 00089 idf_input_string(in, _name); 00090 idf_input_string(in, _scoped_name); 00091 in >> _value; 00092 } 00093 00094 //////////////////////////////////////////////////////////////////// 00095 // Function: InterrogateType::Copy Assignment Operator 00096 // Access: Public 00097 // Description: 00098 //////////////////////////////////////////////////////////////////// 00099 void InterrogateType:: 00100 operator = (const InterrogateType ©) { 00101 InterrogateComponent::operator = (copy); 00102 _flags = copy._flags; 00103 _scoped_name = copy._scoped_name; 00104 _true_name = copy._true_name; 00105 _comment = copy._comment; 00106 _outer_class = copy._outer_class; 00107 _atomic_token = copy._atomic_token; 00108 _wrapped_type = copy._wrapped_type; 00109 _constructors = copy._constructors; 00110 _destructor = copy._destructor; 00111 _elements = copy._elements; 00112 _methods = copy._methods; 00113 _make_seqs = copy._make_seqs; 00114 _casts = copy._casts; 00115 _derivations = copy._derivations; 00116 _enum_values = copy._enum_values; 00117 _nested_types = copy._nested_types; 00118 00119 _cpptype = copy._cpptype; 00120 _cppscope = copy._cppscope; 00121 } 00122 00123 //////////////////////////////////////////////////////////////////// 00124 // Function: InterrogateType::merge_with 00125 // Access: Public 00126 // Description: Combines type with the other similar definition. If 00127 // one type is "fully defined" and the other one isn't, 00128 // the fully-defined type wins. 00129 //////////////////////////////////////////////////////////////////// 00130 void InterrogateType:: 00131 merge_with(const InterrogateType &other) { 00132 // The only thing we care about copying from the non-fully-defined 00133 // type right now is the global flag. 00134 00135 if (is_fully_defined()) { 00136 // We win. 00137 _flags |= (other._flags & F_global); 00138 00139 } else { 00140 // They win. 00141 int old_flags = (_flags & F_global); 00142 (*this) = other; 00143 _flags |= old_flags; 00144 } 00145 } 00146 00147 //////////////////////////////////////////////////////////////////// 00148 // Function: InterrogateType::output 00149 // Access: Public 00150 // Description: Formats the InterrogateType data for output to a data 00151 // file. 00152 //////////////////////////////////////////////////////////////////// 00153 void InterrogateType:: 00154 output(ostream &out) const { 00155 InterrogateComponent::output(out); 00156 00157 out << _flags << " "; 00158 idf_output_string(out, _scoped_name); 00159 idf_output_string(out, _true_name); 00160 out << _outer_class << " " 00161 << (int)_atomic_token << " " 00162 << _wrapped_type << " "; 00163 idf_output_vector(out, _constructors); 00164 out << _destructor << " "; 00165 idf_output_vector(out, _elements); 00166 idf_output_vector(out, _methods); 00167 idf_output_vector(out, _make_seqs); 00168 idf_output_vector(out, _casts); 00169 idf_output_vector(out, _derivations); 00170 idf_output_vector(out, _enum_values); 00171 idf_output_vector(out, _nested_types); 00172 idf_output_string(out, _comment, '\n'); 00173 } 00174 00175 //////////////////////////////////////////////////////////////////// 00176 // Function: InterrogateType::input 00177 // Access: Public 00178 // Description: Reads the data file as previously formatted by 00179 // output(). 00180 //////////////////////////////////////////////////////////////////// 00181 void InterrogateType:: 00182 input(istream &in) { 00183 InterrogateComponent::input(in); 00184 00185 in >> _flags; 00186 idf_input_string(in, _scoped_name); 00187 idf_input_string(in, _true_name); 00188 00189 in >> _outer_class; 00190 int token; 00191 in >> token; 00192 _atomic_token = (AtomicToken)token; 00193 in >> _wrapped_type; 00194 00195 idf_input_vector(in, _constructors); 00196 in >> _destructor; 00197 00198 idf_input_vector(in, _elements); 00199 idf_input_vector(in, _methods); 00200 idf_input_vector(in, _make_seqs); 00201 idf_input_vector(in, _casts); 00202 idf_input_vector(in, _derivations); 00203 idf_input_vector(in, _enum_values); 00204 idf_input_vector(in, _nested_types); 00205 idf_input_string(in, _comment); 00206 } 00207 00208 //////////////////////////////////////////////////////////////////// 00209 // Function: InterrogateType::remap_indices 00210 // Access: Public 00211 // Description: Remaps all internal index numbers according to the 00212 // indicated map. This called from 00213 // InterrogateDatabase::remap_indices(). 00214 //////////////////////////////////////////////////////////////////// 00215 void InterrogateType:: 00216 remap_indices(const IndexRemapper &remap) { 00217 _outer_class = remap.map_from(_outer_class); 00218 _wrapped_type = remap.map_from(_wrapped_type); 00219 00220 Functions::iterator fi; 00221 for (fi = _constructors.begin(); fi != _constructors.end(); ++fi) { 00222 (*fi) = remap.map_from(*fi); 00223 } 00224 _destructor = remap.map_from(_destructor); 00225 00226 Elements::iterator ei; 00227 for (ei = _elements.begin(); ei != _elements.end(); ++ei) { 00228 (*ei) = remap.map_from(*ei); 00229 } 00230 00231 for (fi = _methods.begin(); fi != _methods.end(); ++fi) { 00232 (*fi) = remap.map_from(*fi); 00233 } 00234 for (fi = _casts.begin(); fi != _casts.end(); ++fi) { 00235 (*fi) = remap.map_from(*fi); 00236 } 00237 00238 MakeSeqs::iterator si; 00239 for (si = _make_seqs.begin(); si != _make_seqs.end(); ++si) { 00240 (*si) = remap.map_from(*si); 00241 } 00242 00243 Derivations::iterator di; 00244 for (di = _derivations.begin(); di != _derivations.end(); ++di) { 00245 (*di)._base = remap.map_from((*di)._base); 00246 (*di)._upcast = remap.map_from((*di)._upcast); 00247 (*di)._downcast = remap.map_from((*di)._downcast); 00248 } 00249 00250 Types::iterator ti; 00251 for (ti = _nested_types.begin(); ti != _nested_types.end(); ++ti) { 00252 (*ti) = remap.map_from(*ti); 00253 } 00254 00255 } 00256 00257 00258 //////////////////////////////////////////////////////////////////// 00259 // Function: GetRunTimeDictionary 00260 //////////////////////////////////////////////////////////////////// 00261 EXPCL_DTOOLCONFIG RunTimeTypeDictionary & GetRunTimeDictionary() 00262 { 00263 static RunTimeTypeDictionary dict; 00264 return dict; 00265 }; 00266 00267 //////////////////////////////////////////////////////////////////// 00268 // Function: GetRunTimeTypeList 00269 //////////////////////////////////////////////////////////////////// 00270 EXPCL_DTOOLCONFIG RunTimeTypeList & GetRunTimeTypeList() 00271 { 00272 static RunTimeTypeList list; 00273 return list; 00274 }; 00275