mummy
1.0.2
|
00001 //---------------------------------------------------------------------------- 00002 // 00003 // $Id: MummySettings.cxx 64 2008-03-08 18:10:51Z david.cole $ 00004 // 00005 // $Author: david.cole $ 00006 // $Date: 2008-03-08 13:10:51 -0500 (Sat, 08 Mar 2008) $ 00007 // $Revision: 64 $ 00008 // 00009 // Copyright (C) 2006-2007 Kitware, Inc. 00010 // 00011 //---------------------------------------------------------------------------- 00012 00013 #include "MummySettings.h" 00014 #include "MummyDummyGenerator.h" 00015 #include "MummyLineOrientedTextFileReader.h" 00016 #include "MummyLog.h" 00017 #include "MummyVersion.h" 00018 00019 #include "cableClass.h" 00020 #include "cableNamespace.h" 00021 #include "cableSourceRepresentation.h" 00022 #include "cableVariable.h" 00023 #include "cableXMLParser.h" 00024 00025 #include "gxsys/CommandLineArguments.hxx" 00026 #include "gxsys/RegularExpression.hxx" 00027 #include "gxsys/ios/fstream" 00028 #include "gxsys/ios/iostream" 00029 #include "gxsys/stl/algorithm" 00030 #include "gxsys/stl/map" 00031 #include "gxsys/stl/set" 00032 #include "gxsys/stl/string" 00033 #include "gxsys/stl/vector" 00034 00035 00036 //---------------------------------------------------------------------------- 00037 static gxsys_stl::string Mummy_SVN_STATUS(Mummy_SVN_STATUS_ENCODED); 00038 00039 //---------------------------------------------------------------------------- 00040 class MummySettingsInternals 00041 { 00042 public: 00043 gxsys_stl::string ArgsHelpString; 00044 gxsys_stl::string CsharpFile; 00045 gxsys_stl::string CsharpUnitTestFile; 00046 gxsys_stl::string ExportLayerFile; 00047 gxsys_stl::string GccxmlFile; 00048 gxsys_stl::string Group; 00049 gxsys_stl::string Header; 00050 bool Help; 00051 gxsys_stl::string Package; 00052 gxsys_stl::string PackageVersion; 00053 gxsys_stl::vector<gxsys_stl::string> References; 00054 bool Run; 00055 gxsys_stl::string SettingsFile; 00056 gxsys_stl::vector<int> SuppressedWarnings; 00057 gxsys_stl::map<gxsys_stl::string, ClassWrappingSettings> unwrappable_classes; 00058 gxsys_stl::vector<ClassWrappingSettings> unwrappable_patterns; 00059 bool Verbose; 00060 bool Version; 00061 gxsys_stl::map<gxsys_stl::string, ClassWrappingSettings> wrappable_classes; 00062 gxsys_stl::vector<ClassWrappingSettings> wrappable_patterns; 00063 }; 00064 00065 00066 //---------------------------------------------------------------------------- 00067 MummySettings::MummySettings() 00068 { 00069 this->Internals = new MummySettingsInternals; 00070 this->Reset(); 00071 } 00072 00073 00074 //---------------------------------------------------------------------------- 00075 MummySettings::~MummySettings() 00076 { 00077 delete this->Internals; 00078 } 00079 00080 00081 //---------------------------------------------------------------------------- 00082 void MummySettings::Reset() 00083 { 00084 this->Internals->ArgsHelpString = ""; 00085 this->Internals->CsharpFile = ""; 00086 this->Internals->CsharpUnitTestFile = ""; 00087 this->Internals->ExportLayerFile = ""; 00088 this->Internals->GccxmlFile = ""; 00089 this->Internals->Group = ""; 00090 this->Internals->Header = ""; 00091 this->Internals->Help = false; 00092 this->Internals->Package = ""; 00093 this->Internals->PackageVersion = ""; 00094 this->Internals->References.clear(); 00095 this->Internals->Run = true; 00096 this->Internals->SettingsFile = ""; 00097 this->Internals->SuppressedWarnings.clear(); 00098 this->Internals->unwrappable_classes.clear(); 00099 this->Internals->unwrappable_patterns.clear(); 00100 this->Internals->Verbose = false; 00101 this->Internals->Version = false; 00102 this->Internals->wrappable_classes.clear(); 00103 this->Internals->wrappable_patterns.clear(); 00104 } 00105 00106 00107 //---------------------------------------------------------------------------- 00108 void MummySettings::AddArgumentHandlers(gxsys::CommandLineArguments& arguments) 00109 { 00110 arguments.AddArgument( 00111 "--settings-file", 00112 gxsys::CommandLineArguments::SPACE_ARGUMENT, 00113 &this->Internals->SettingsFile, 00114 "Input file describing mummy configuration settings, including the set of wrapped classes. Required." 00115 ); 00116 00117 arguments.AddArgument( 00118 "--csharp-file", 00119 gxsys::CommandLineArguments::SPACE_ARGUMENT, 00120 &this->Internals->CsharpFile, 00121 "C# output file. Default value is 'ClassName.cs' in the current directory." 00122 ); 00123 00124 arguments.AddArgument( 00125 "--export-layer-file", 00126 gxsys::CommandLineArguments::SPACE_ARGUMENT, 00127 &this->Internals->ExportLayerFile, 00128 "C++ output file. Default value is 'ClassNameEL.cxx' in the current directory." 00129 ); 00130 00131 arguments.AddArgument( 00132 "--csharp-unit-test-file", 00133 gxsys::CommandLineArguments::SPACE_ARGUMENT, 00134 &this->Internals->CsharpUnitTestFile, 00135 "C# output file. Default value is 'ClassNameUnitTest.cs' in the current directory." 00136 ); 00137 00138 arguments.AddArgument( 00139 "--gccxml-file", 00140 gxsys::CommandLineArguments::SPACE_ARGUMENT, 00141 &this->Internals->GccxmlFile, 00142 "Input file (output of gccxml) describing class to be wrapped. Required." 00143 ); 00144 00145 arguments.AddCallback( 00146 "--help", 00147 gxsys::CommandLineArguments::NO_ARGUMENT, 00148 MummySettings::DisplayHelp, 00149 this, 00150 "Display (this) detailed help information." 00151 ); 00152 00153 arguments.AddArgument( 00154 "--verbose", 00155 gxsys::CommandLineArguments::NO_ARGUMENT, 00156 &this->Internals->Verbose, 00157 "Overwhelm me with output, I don't have enough reading material... ;)" 00158 ); 00159 00160 arguments.AddCallback( 00161 "--version", 00162 gxsys::CommandLineArguments::NO_ARGUMENT, 00163 MummySettings::DisplayVersion, 00164 this, 00165 "Display the program version." 00166 ); 00167 00168 arguments.AddArgument( 00169 "--suppress-warnings", 00170 gxsys::CommandLineArguments::MULTI_ARGUMENT, 00171 &this->Internals->SuppressedWarnings, 00172 "Space separated list of warning numbers to suppress." 00173 ); 00174 } 00175 00176 00177 //---------------------------------------------------------------------------- 00178 int MummySettings::Initialize(int argc, char *argv[]) 00179 { 00180 int err = 0; 00181 00182 gxsys::CommandLineArguments arguments; 00183 00184 this->Reset(); 00185 00186 arguments.Initialize(argc, argv); 00187 00188 this->AddArgumentHandlers(arguments); 00189 00190 // Stash big help string in case we process "--help" during the Parse: 00191 this->Internals->ArgsHelpString = arguments.GetHelp(); 00192 00193 if (!arguments.Parse()) 00194 { 00195 err = me_CouldNotParse; 00196 LogError(err, << "Could not parse all arguments in MummySettings::Initialize. Use --help for detailed help information."); 00197 } 00198 00199 if (!err && this->ShouldRun()) 00200 { 00201 gxsys_stl::vector<int>::iterator wit; 00202 for (wit = this->Internals->SuppressedWarnings.begin(); 00203 wit != this->Internals->SuppressedWarnings.end(); 00204 ++wit) 00205 { 00206 SuppressMsg(*wit); 00207 } 00208 00209 if (this->Internals->SettingsFile == "") 00210 { 00211 err = me_MissingRequiredCommandLineArg; 00212 LogError(err, << "Required setting --settings-file not given. Use --help for detailed help information."); 00213 } 00214 00215 if (!err && this->Internals->GccxmlFile == "") 00216 { 00217 err = me_MissingRequiredCommandLineArg; 00218 LogError(err, << "Required setting --gccxml-file not given. Use --help for detailed help information."); 00219 } 00220 00221 if (!err && this->Internals->Verbose) 00222 { 00223 LogInfo(mi_VerboseInfo, << "--verbose mode turned on."); 00224 } 00225 00226 if (!err) 00227 { 00228 err = this->ParseSettingsFile(this->GetSettingsFileName()); 00229 } 00230 } 00231 00232 return err; 00233 } 00234 00235 00236 //---------------------------------------------------------------------------- 00237 void MummySettings::AddUnwrappableClass(const ClassWrappingSettings &cws) 00238 { 00239 this->Internals->unwrappable_classes.insert(gxsys_stl::make_pair(cws.name, cws)); 00240 } 00241 00242 00243 //---------------------------------------------------------------------------- 00244 void MummySettings::AddWrappableClass(const ClassWrappingSettings &cws) 00245 { 00246 this->Internals->wrappable_classes.insert(gxsys_stl::make_pair(cws.name, cws)); 00247 } 00248 00249 00250 //---------------------------------------------------------------------------- 00251 void MummySettings::AddUnwrappablePattern(const ClassWrappingSettings &cws) 00252 { 00253 this->Internals->unwrappable_patterns.push_back(cws); 00254 } 00255 00256 00257 //---------------------------------------------------------------------------- 00258 struct SortBySortKey 00259 { 00260 bool operator()(const ClassWrappingSettings& c1, const ClassWrappingSettings& c2) 00261 { 00262 return c1.sortkey < c2.sortkey; 00263 } 00264 }; 00265 00266 00267 //---------------------------------------------------------------------------- 00268 void MummySettings::AddWrappablePattern(const ClassWrappingSettings &cws) 00269 { 00270 this->Internals->wrappable_patterns.push_back(cws); 00271 00272 // Sort the vector by sortkey now that a new pattern has been added: 00273 // 00274 gxsys_stl::sort(this->Internals->wrappable_patterns.begin(), 00275 this->Internals->wrappable_patterns.end(), SortBySortKey()); 00276 } 00277 00278 00279 //---------------------------------------------------------------------------- 00280 void MummySettings::AddReference(const char *name) 00281 { 00282 if (name) 00283 { 00284 this->Internals->References.push_back(gxsys_stl::string(name)); 00285 } 00286 } 00287 00288 00289 //---------------------------------------------------------------------------- 00290 void MummySettings::GetReferences(gxsys_stl::vector<gxsys_stl::string>& references) 00291 { 00292 references.clear(); 00293 references.insert(references.begin(), 00294 this->Internals->References.begin(), this->Internals->References.end()); 00295 } 00296 00297 00298 //---------------------------------------------------------------------------- 00299 bool MummySettings::FindClassWrappingSettings(const char *name, ClassWrappingSettings* cws) 00300 { 00301 bool found = false; 00302 00303 if (name) 00304 { 00305 gxsys_stl::map<gxsys_stl::string, ClassWrappingSettings>::iterator mit; 00306 gxsys_stl::vector<ClassWrappingSettings>::iterator vit; 00307 gxsys::RegularExpression re; 00308 gxsys_stl::string s(name); 00309 00310 mit = this->Internals->wrappable_classes.find(s); 00311 if (mit != this->Internals->wrappable_classes.end()) 00312 { 00313 found = true; 00314 if (cws) 00315 { 00316 (*cws) = mit->second; 00317 } 00318 } 00319 00320 for (vit = this->Internals->wrappable_patterns.begin(); 00321 !found && vit != this->Internals->wrappable_patterns.end(); ++vit) 00322 { 00323 re.compile(vit->pattern.c_str()); 00324 if (re.find(s.c_str())) 00325 { 00326 found = true; 00327 if (cws) 00328 { 00329 (*cws) = *vit; 00330 } 00331 } 00332 } 00333 } 00334 00335 return found; 00336 } 00337 00338 00339 //---------------------------------------------------------------------------- 00340 bool MummySettings::ClassIsWrappable(const cable::Class *c) 00341 { 00342 bool wrappable = false; 00343 00344 // A class is wrappable if: 00345 // - it is not excluded by name or pattern match *and* 00346 // - it is included by name or pattern match 00347 00348 if (c) 00349 { 00350 gxsys_stl::map<gxsys_stl::string, ClassWrappingSettings>::iterator mit; 00351 gxsys_stl::vector<ClassWrappingSettings>::iterator vit; 00352 gxsys::RegularExpression re; 00353 gxsys_stl::string s(GetFullyQualifiedNameForCPlusPlus(c)); 00354 00355 mit = this->Internals->unwrappable_classes.find(s); 00356 if (mit != this->Internals->unwrappable_classes.end()) 00357 { 00358 return false; 00359 } 00360 00361 for (vit = this->Internals->unwrappable_patterns.begin(); 00362 vit != this->Internals->unwrappable_patterns.end(); ++vit) 00363 { 00364 re.compile(vit->pattern.c_str()); 00365 if (re.find(s.c_str())) 00366 { 00367 return false; 00368 } 00369 } 00370 00371 wrappable = FindClassWrappingSettings(s.c_str(), 0); 00372 } 00373 00374 return wrappable; 00375 } 00376 00377 00378 //---------------------------------------------------------------------------- 00379 #define READ_MummySettings_ATTS() \ 00380 { \ 00381 if (s=="beginExcludeRegex"){attBeginExcludeRegex = atts[i+1];knownAttribute = true;} \ 00382 if (s=="countedMethodsRegex"){attCountedMethodsRegex = atts[i+1];knownAttribute = true;} \ 00383 if (s=="csharpConstructorModifier"){attCsharpConstructorModifier = atts[i+1];knownAttribute = true;} \ 00384 if (s=="defaultDisposalMethod"){attDefaultDisposalMethod = atts[i+1];knownAttribute = true;} \ 00385 if (s=="defaultFactoryMethod"){attDefaultFactoryMethod = atts[i+1];knownAttribute = true;} \ 00386 if (s=="emitDefaultFactoryMethod"){attEmitDefaultFactoryMethod = atts[i+1];knownAttribute = true;} \ 00387 if (s=="endExcludeRegex"){attEndExcludeRegex = atts[i+1];knownAttribute = true;} \ 00388 if (s=="exceptionBaseClass"){attExceptionBaseClass = atts[i+1];knownAttribute = true;} \ 00389 if (s=="exceptionCloneMethod"){attExceptionCloneMethod = atts[i+1];knownAttribute = true;} \ 00390 if (s=="exceptionInclude"){attExceptionInclude = atts[i+1];knownAttribute = true;} \ 00391 if (s=="excludeMarkedLines"){attExcludeMarkedLines = atts[i+1];knownAttribute = true;} \ 00392 if (s=="externalHints"){attExternalHints = atts[i+1];knownAttribute = true;} \ 00393 if (s=="extraCsharpCode"){attExtraCsharpCode = atts[i+1];knownAttribute = true;} \ 00394 if (s=="extraCsharpUnitTestCode"){attExtraCsharpUnitTestCode = atts[i+1];knownAttribute = true;} \ 00395 if (s=="extraExportLayerCode"){attExtraExportLayerCode = atts[i+1];knownAttribute = true;} \ 00396 if (s=="getMummyTypeEntryMethod"){attGetMummyTypeEntryMethod = atts[i+1];knownAttribute = true;} \ 00397 if (s=="getRefCountMethod"){attGetRefCountMethod = atts[i+1];knownAttribute = true;} \ 00398 if (s=="partial"){attPartial = atts[i+1];knownAttribute = true;} \ 00399 if (s=="registerBaseClass"){attRegisterBaseClass = atts[i+1];knownAttribute = true;} \ 00400 if (s=="registerMethod"){attRegisterMethod = atts[i+1];knownAttribute = true;} \ 00401 if (s=="registerInclude"){attRegisterInclude = atts[i+1];knownAttribute = true;} \ 00402 if (s=="setMummyTypeEntryMethod"){attSetMummyTypeEntryMethod = atts[i+1];knownAttribute = true;} \ 00403 if (s=="shadow"){attShadow = atts[i+1];knownAttribute = true;} \ 00404 if (s=="unRegisterMethod"){attUnRegisterMethod = atts[i+1];knownAttribute = true;} \ 00405 if (s=="wrappedObjectBase"){attWrappedObjectBase = atts[i+1];knownAttribute = true;} \ 00406 } 00407 00408 00409 //---------------------------------------------------------------------------- 00410 namespace cable 00411 { 00412 class SettingsParser : public XMLParser 00413 { 00414 public: 00415 cableTypeMacro(SettingsParser, XMLParser); 00416 static Pointer New() { return new Self; } 00417 00418 MummySettings* GetSettings() { return this->Settings; } 00419 void SetSettings(MummySettings* settings) { this->Settings = settings; } 00420 00421 protected: 00422 virtual void StartElement(const char* name, const char** atts) 00423 { 00424 gxsys_stl::string elementName(name); 00425 00426 gxsys_stl::string attName; 00427 gxsys_stl::string attPattern; 00428 gxsys_stl::string attSortKey; 00429 gxsys_stl::string attWrappable; 00430 00431 gxsys_stl::string attCsharpConstructorModifier(""); 00432 gxsys_stl::string attDefaultDisposalMethod(""); 00433 gxsys_stl::string attDefaultFactoryMethod(""); 00434 gxsys_stl::string attEmitDefaultFactoryMethod("false"); 00435 gxsys_stl::string attCountedMethodsRegex(""); 00436 gxsys_stl::string attShadow("false"); 00437 gxsys_stl::string attExceptionBaseClass(""); 00438 gxsys_stl::string attExceptionCloneMethod(""); 00439 gxsys_stl::string attExceptionInclude(""); 00440 gxsys_stl::string attExternalHints(""); 00441 gxsys_stl::string attExtraCsharpCode(""); 00442 gxsys_stl::string attExtraCsharpUnitTestCode(""); 00443 gxsys_stl::string attExtraExportLayerCode(""); 00444 gxsys_stl::string attPartial("false"); 00445 gxsys_stl::string attRegisterMethod(""); 00446 gxsys_stl::string attUnRegisterMethod(""); 00447 gxsys_stl::string attRegisterBaseClass(""); 00448 gxsys_stl::string attRegisterInclude(""); 00449 gxsys_stl::string attGetRefCountMethod(""); 00450 gxsys_stl::string attGetMummyTypeEntryMethod(""); 00451 gxsys_stl::string attSetMummyTypeEntryMethod(""); 00452 gxsys_stl::string attExcludeMarkedLines("false"); 00453 gxsys_stl::string attBeginExcludeRegex(""); 00454 gxsys_stl::string attEndExcludeRegex(""); 00455 gxsys_stl::string attWrappedObjectBase(""); 00456 00457 gxsys_stl::string s; 00458 bool knownAttribute = false; 00459 00460 00461 if (elementName == "Class") 00462 { 00463 for (unsigned int i=0; atts[i] && atts[i+1]; i+=2) 00464 { 00465 s = atts[i]; 00466 knownAttribute = false; 00467 00468 if (s=="name"){attName = atts[i+1];knownAttribute = true;} 00469 if (s=="wrappable"){attWrappable = atts[i+1];knownAttribute = true;} 00470 00471 READ_MummySettings_ATTS(); 00472 00473 if (!knownAttribute) 00474 { 00475 LogWarning(mw_UnknownAttribute, "Unknown XML attribute '" 00476 << elementName << "/@" << s << "'"); 00477 } 00478 } 00479 00480 ClassWrappingSettings cws( 00481 attName, 00482 attPattern, 00483 attSortKey, 00484 attDefaultFactoryMethod, 00485 attEmitDefaultFactoryMethod == "false" ? false : true, 00486 attCountedMethodsRegex, 00487 attDefaultDisposalMethod, 00488 attShadow == "false" ? false : true, 00489 attExternalHints, 00490 attExtraExportLayerCode, 00491 attExtraCsharpCode, 00492 attExtraCsharpUnitTestCode, 00493 attCsharpConstructorModifier, 00494 attRegisterMethod, 00495 attUnRegisterMethod, 00496 attGetRefCountMethod, 00497 attRegisterBaseClass, 00498 attRegisterInclude, 00499 attGetMummyTypeEntryMethod, 00500 attSetMummyTypeEntryMethod, 00501 attExcludeMarkedLines == "false" ? false : true, 00502 attBeginExcludeRegex, 00503 attEndExcludeRegex, 00504 attPartial == "false" ? false : true, 00505 attExceptionBaseClass, 00506 attExceptionCloneMethod, 00507 attExceptionInclude, 00508 attWrappedObjectBase 00509 ); 00510 00511 if (attWrappable == "false") 00512 { 00513 this->GetSettings()->AddUnwrappableClass(cws); 00514 } 00515 else 00516 { 00517 this->GetSettings()->AddWrappableClass(cws); 00518 } 00519 } 00520 00521 00522 if (elementName == "ClassPattern") 00523 { 00524 for (unsigned int i=0; atts[i] && atts[i+1]; i+=2) 00525 { 00526 s = atts[i]; 00527 knownAttribute = false; 00528 00529 if (s=="pattern"){attPattern = atts[i+1];knownAttribute = true;} 00530 if (s=="wrappable"){attWrappable = atts[i+1];knownAttribute = true;} 00531 if (s=="sortkey"){attSortKey = atts[i+1];knownAttribute = true;} 00532 00533 READ_MummySettings_ATTS(); 00534 00535 if (!knownAttribute) 00536 { 00537 LogWarning(mw_UnknownAttribute, "Unknown XML attribute '" 00538 << elementName << "/@" << s << "'"); 00539 } 00540 } 00541 00542 ClassWrappingSettings cws( 00543 attName, 00544 attPattern, 00545 attSortKey, 00546 attDefaultFactoryMethod, 00547 attEmitDefaultFactoryMethod == "false" ? false : true, 00548 attCountedMethodsRegex, 00549 attDefaultDisposalMethod, 00550 attShadow == "false" ? false : true, 00551 attExternalHints, 00552 attExtraExportLayerCode, 00553 attExtraCsharpCode, 00554 attExtraCsharpUnitTestCode, 00555 attCsharpConstructorModifier, 00556 attRegisterMethod, 00557 attUnRegisterMethod, 00558 attGetRefCountMethod, 00559 attRegisterBaseClass, 00560 attRegisterInclude, 00561 attGetMummyTypeEntryMethod, 00562 attSetMummyTypeEntryMethod, 00563 attExcludeMarkedLines == "false" ? false : true, 00564 attBeginExcludeRegex, 00565 attEndExcludeRegex, 00566 attPartial == "false" ? false : true, 00567 attExceptionBaseClass, 00568 attExceptionCloneMethod, 00569 attExceptionInclude, 00570 attWrappedObjectBase 00571 ); 00572 00573 if (attWrappable == "false") 00574 { 00575 this->GetSettings()->AddUnwrappablePattern(cws); 00576 } 00577 else 00578 { 00579 this->GetSettings()->AddWrappablePattern(cws); 00580 } 00581 } 00582 00583 00584 if (elementName == "Reference") 00585 { 00586 for (unsigned int i=0; atts[i] && atts[i+1]; i+=2) 00587 { 00588 s = atts[i]; 00589 knownAttribute = false; 00590 00591 if (s=="name"){attName = atts[i+1];knownAttribute = true;} 00592 00593 if (!knownAttribute) 00594 { 00595 LogWarning(mw_UnknownAttribute, "Unknown XML attribute '" 00596 << elementName << "/@" << s << "'"); 00597 } 00598 } 00599 00600 this->GetSettings()->AddReference(attName.c_str()); 00601 } 00602 } 00603 00604 private: 00605 MummySettings *Settings; 00606 }; 00607 } 00608 00609 00610 //---------------------------------------------------------------------------- 00611 int MummySettings::ParseSettingsFile(const char *filename) 00612 { 00613 int err = 0; 00614 00615 // The settings file shall be an XML file that lists classes explicitly 00616 // declared as wrapped or not, something like this: 00617 // 00618 // <MummySettings> 00619 // <Class name="vtkCommand" wrappable="true" defaultFactoryMethod="New" defaultDisposalMethod="Delete" shadow="true"/> 00620 // <ClassPattern pattern="^vtk" wrappable="true" defaultFactoryMethod="New" defaultDisposalMethod="Delete" shadow="false"/> 00621 // </MummySettings> 00622 // 00623 // Where the name of the class is the fully qualified C++ class name and 00624 // the only valid values for the wrapped attribute are the lower case 00625 // boolean constants "true" and "false". 00626 00627 if (this->GetVerbose()) 00628 { 00629 LogInfo(mi_VerboseInfo, << "Using --settings-file '" << filename << "'"); 00630 } 00631 00632 gxsys_ios::ifstream inFile(filename, std::ios_base::in|std::ios_base::binary); 00633 if (!inFile) 00634 { 00635 err = me_CouldNotOpen; 00636 LogFileLineErrorMsg(filename, 1, 00637 err, << "Could not open file: '" << filename << "'"); 00638 } 00639 00640 if (!err) 00641 { 00642 cable::SettingsParser::Pointer parser = cable::SettingsParser::New(); 00643 parser->SetStream(&inFile); 00644 parser->SetSettings(this); 00645 if(!parser->Parse()) 00646 { 00647 err = me_CouldNotParse; 00648 LogFileLineErrorMsg(filename, 1, 00649 err, << "Could not parse file: '" << filename << "'"); 00650 } 00651 parser->SetStream(0); 00652 parser->SetSettings(0); 00653 inFile.close(); 00654 } 00655 00656 return err; 00657 } 00658 00659 00660 //---------------------------------------------------------------------------- 00661 bool ParseName(const char* name, gxsys_stl::string& result) 00662 { 00663 gxsys_stl::string group = name; 00664 gxsys_stl::string::size_type l = group.find('"'); 00665 gxsys_stl::string::size_type r = group.rfind('"'); 00666 if((l != gxsys_stl::string::npos) && (r != gxsys_stl::string::npos) && (r > l)) 00667 { 00668 result = group.substr(l+1, r-l-1); 00669 return true; 00670 } 00671 return false; 00672 } 00673 00674 00675 //---------------------------------------------------------------------------- 00676 bool GetGroupAndPackageInformation(cable::Namespace* cns, 00677 gxsys_stl::string& groupName, 00678 gxsys_stl::vector<gxsys_stl::string>& groupsNames, 00679 gxsys_stl::string& packageName, 00680 gxsys_stl::string& packageVersion, 00681 gxsys_stl::string& headerName, 00682 gxsys_stl::string& configFile) 00683 { 00684 // Find the group, if any. 00685 const cable::Variable* group = 0; 00686 cable::Context::Iterator lower = cns->LowerBound("group"); 00687 cable::Context::Iterator upper = cns->UpperBound("group"); 00688 if (lower != upper) 00689 { 00690 group = cable::Variable::SafeDownCast(*lower); 00691 if (!group) 00692 { 00693 LogError(me_UnexpectedGccxmlInput, << "Identifier _cable_::group is not a variable."); 00694 return false; 00695 } 00696 } 00697 00698 // Find the groups list, if any. 00699 const cable::Variable* groups = 0; 00700 lower = cns->LowerBound("groups"); 00701 upper = cns->UpperBound("groups"); 00702 if (lower != upper) 00703 { 00704 groups = cable::Variable::SafeDownCast(*lower); 00705 if (!groups) 00706 { 00707 LogError(me_UnexpectedGccxmlInput, << "Identifier _cable_::groups is not a variable."); 00708 return false; 00709 } 00710 } 00711 00712 // Find the package name, if any. 00713 const cable::Variable* package = 0; 00714 lower = cns->LowerBound("package"); 00715 upper = cns->UpperBound("package"); 00716 if (lower != upper) 00717 { 00718 package = cable::Variable::SafeDownCast(*lower); 00719 if (!package) 00720 { 00721 LogError(me_UnexpectedGccxmlInput, << "Identifier _cable_::package is not a variable."); 00722 return false; 00723 } 00724 } 00725 00726 // Find the package version, if any. 00727 const cable::Variable* package_version = 0; 00728 lower = cns->LowerBound("package_version"); 00729 upper = cns->UpperBound("package_version"); 00730 if (lower != upper) 00731 { 00732 package_version = cable::Variable::SafeDownCast(*lower); 00733 if (!package_version) 00734 { 00735 LogError(me_UnexpectedGccxmlInput, << "Identifier _cable_::package_version is not a variable."); 00736 return false; 00737 } 00738 } 00739 00740 // Find the header, if any. 00741 const cable::Variable* header = 0; 00742 lower = cns->LowerBound("header"); 00743 upper = cns->UpperBound("header"); 00744 if (lower != upper) 00745 { 00746 header = cable::Variable::SafeDownCast(*lower); 00747 if (!header) 00748 { 00749 LogError(me_UnexpectedGccxmlInput, << "Identifier _cable_::header is not a variable."); 00750 return false; 00751 } 00752 } 00753 00754 // Parse the strings out of the found entities: 00755 // 00756 if (group) 00757 { 00758 if (!ParseName(group->GetInitializer(), groupName)) 00759 { 00760 LogError(me_CouldNotParse, << "Error parsing group name."); 00761 return false; 00762 } 00763 00764 // Hold on to the name of the configuration file. 00765 configFile = group->GetFile(); 00766 } 00767 00768 if (package && !ParseName(package->GetInitializer(), packageName)) 00769 { 00770 LogError(me_CouldNotParse, << "Error parsing package name."); 00771 return false; 00772 } 00773 00774 if (package_version && 00775 !ParseName(package_version->GetInitializer(), packageVersion)) 00776 { 00777 LogError(me_CouldNotParse, << "Error parsing package_version string."); 00778 return false; 00779 } 00780 00781 if (groups) 00782 { 00783 gxsys_stl::string gl = groups->GetInitializer(); 00784 gxsys_stl::string::size_type lpos = gl.find('"'); 00785 while((lpos != gxsys_stl::string::npos) && (lpos < gl.length())) 00786 { 00787 gxsys_stl::string::size_type rpos = gl.find_first_of(",}", lpos); 00788 gxsys_stl::string result; 00789 if((rpos == gxsys_stl::string::npos) || 00790 !ParseName(gl.substr(lpos, rpos-lpos).c_str(), result)) 00791 { 00792 LogError(me_CouldNotParse, << "Error parsing groups list."); 00793 return false; 00794 } 00795 groupsNames.push_back(result); 00796 lpos = rpos+1; 00797 } 00798 } 00799 00800 if (header) 00801 { 00802 if (!ParseName(header->GetInitializer(), headerName)) 00803 { 00804 LogError(me_CouldNotParse, << "Error parsing header name."); 00805 return false; 00806 } 00807 } 00808 00809 return true; 00810 } 00811 00812 00813 //---------------------------------------------------------------------------- 00814 int MummySettings::ProcessSource(cable::SourceRepresentation* sr) 00815 { 00816 int err = 0; 00817 00818 if (!sr) 00819 { 00820 LogError(me_InvalidArg, << "NULL pointer!"); 00821 return me_InvalidArg; 00822 } 00823 00824 gxsys_stl::string s; 00825 const cable::Namespace* gns = sr->GetGlobalNamespace(); 00826 00827 // Look inside the _cable_ namespace for package, packageversion and 00828 // group settings: 00829 // 00830 cable::Context::Iterator lower = gns->LowerBound("_cable_"); 00831 cable::Context::Iterator upper = gns->UpperBound("_cable_"); 00832 cable::Namespace* cns = 0; 00833 if (lower != upper) 00834 { 00835 cns = cable::Namespace::SafeDownCast(*lower); 00836 } 00837 if (!cns) 00838 { 00839 LogError(me_UnexpectedGccxmlInput, << "No _cable_ namespace."); 00840 return me_UnexpectedGccxmlInput; 00841 } 00842 00843 gxsys_stl::string group; 00844 gxsys_stl::vector<gxsys_stl::string> groups; 00845 gxsys_stl::string package; 00846 gxsys_stl::string packageVersion; 00847 gxsys_stl::string header; 00848 gxsys_stl::string configFile; 00849 GetGroupAndPackageInformation(cns, group, groups, package, packageVersion, header, configFile); 00850 if (group.size() == 0) 00851 { 00852 if (package.size() == 0) 00853 { 00854 LogError(me_UnexpectedGccxmlInput, << "No group or package name specified."); 00855 return me_UnexpectedGccxmlInput; 00856 } 00857 } 00858 00859 // Save for when clients query us later: 00860 // 00861 this->Internals->Group = group; 00862 this->Internals->Header = header; 00863 this->Internals->Package = package; 00864 this->Internals->PackageVersion = packageVersion; 00865 00866 return err; 00867 } 00868 00869 00870 //---------------------------------------------------------------------------- 00871 static void IncreaseCoverage(MummySettings *settings) 00872 { 00873 // This function exists only to add test calls to functions that are 00874 // otherwise not commonly called so that they get some sort of coverage 00875 // on coverage dashboards... 00876 // 00877 Trace("IncreaseCoverage\n"); 00878 00879 MummyDummyGenerator mg; 00880 mg.FundamentalTypeIsWrappable(0); 00881 mg.TypeIsWrappable(0); 00882 mg.FunctionTypeIsWrappable(0); 00883 mg.MethodIsWrappable(0, cable::Context::Public); 00884 mg.ClassIsWrappable(0); 00885 mg.GenerateWrappers(); 00886 00887 GetMostRecentErrorValue(); 00888 GetNthErrorValue(-10); 00889 GetNthErrorValue(0); // valid if there have been any errors... 00890 GetNthErrorValue(GetErrorCount()-1); // valid if there have been any errors... 00891 GetNthErrorValue(GetErrorCount()); 00892 GetNthErrorValue(GetErrorCount()+10); 00893 00894 // Can't do this... then the test that calls this code fails because there 00895 // was an "error"...... 00896 // 00897 //LogError(me_InternalError, 00898 // << "This is not really an error." << gxsys_ios::endl 00899 // << " This is IncreaseCoverage increasing the coverage of the" << gxsys_ios::endl 00900 // << " MummyUtilities error functions..." 00901 // ); 00902 //GetNthErrorValue(-10); 00903 //GetNthErrorValue(0); // valid if there have been any errors... 00904 //GetNthErrorValue(GetErrorCount()-1); // valid if there have been any errors... 00905 //GetNthErrorValue(GetErrorCount()); 00906 //GetNthErrorValue(GetErrorCount()+10); 00907 00908 EncodeStringForXml(0); 00909 EncodeStringForXml(""); 00910 00911 settings->GetHeader(); 00912 settings->GetPackageVersion(); 00913 00914 MummyLineOrientedTextFileReader reader; 00915 reader.SetFileName(0); 00916 } 00917 00918 00919 //---------------------------------------------------------------------------- 00920 int MummySettings::DisplayHelp(const char* argument, const char* value, 00921 void* call_data) 00922 { 00923 MummySettings *settings = (MummySettings *) call_data; 00924 00925 DisplayVersion(argument, value, call_data); 00926 00927 // If run under a ctest driven dashboard test, emit the string that tells 00928 // ctest not to truncate the test output: 00929 // 00930 if (getenv("DART_TEST_FROM_DART")) 00931 { 00932 gxsys_ios::cout << gxsys_ios::endl; 00933 gxsys_ios::cout << "CTEST_FULL_OUTPUT (Avoid ctest truncation of output)" << gxsys_ios::endl; 00934 } 00935 00936 gxsys_ios::cout << gxsys_ios::endl; 00937 gxsys_ios::cout << "Command line options:" << gxsys_ios::endl; 00938 gxsys_ios::cout << settings->Internals->ArgsHelpString << gxsys_ios::endl; 00939 00940 if (!Mummy_SVN_STATUS.empty()) 00941 { 00942 gxsys_ios::cout << gxsys_ios::endl; 00943 gxsys_ios::cout << "svn status (retrieved at CMake configure time):" << gxsys_ios::endl; 00944 gxsys_ios::cout << "===============================================" << gxsys_ios::endl; 00945 gxsys_ios::cout << Mummy_SVN_STATUS.c_str() << gxsys_ios::endl; 00946 gxsys_ios::cout << gxsys_ios::endl; 00947 } 00948 00949 IncreaseCoverage(settings); 00950 00951 settings->Internals->Help = true; 00952 settings->Internals->Run = false; 00953 return 1; 00954 } 00955 00956 00957 //---------------------------------------------------------------------------- 00958 int MummySettings::DisplayVersion(const char*, const char*, void* call_data) 00959 { 00960 MummySettings *settings = (MummySettings *) call_data; 00961 00962 gxsys_ios::cout << settings->GetMummyVersion() << gxsys_ios::endl; 00963 00964 settings->Internals->Version = true; 00965 settings->Internals->Run = false; 00966 return 1; 00967 } 00968 00969 00970 //---------------------------------------------------------------------------- 00971 gxsys_stl::string MummySettings::GetMummyVersion() 00972 { 00973 return Mummy_FULL_VERSION_STRING; 00974 } 00975 00976 00977 //---------------------------------------------------------------------------- 00978 const char *MummySettings::GetSettingsFileName() 00979 { 00980 return this->Internals->SettingsFile.c_str(); 00981 } 00982 00983 00984 //---------------------------------------------------------------------------- 00985 const char *MummySettings::GetCsharpFileName() 00986 { 00987 return this->Internals->CsharpFile.c_str(); 00988 } 00989 00990 00991 //---------------------------------------------------------------------------- 00992 const char *MummySettings::GetExportLayerFileName() 00993 { 00994 return this->Internals->ExportLayerFile.c_str(); 00995 } 00996 00997 00998 //---------------------------------------------------------------------------- 00999 const char *MummySettings::GetCsharpUnitTestFileName() 01000 { 01001 return this->Internals->CsharpUnitTestFile.c_str(); 01002 } 01003 01004 01005 //---------------------------------------------------------------------------- 01006 const char *MummySettings::GetGccxmlFileName() 01007 { 01008 return this->Internals->GccxmlFile.c_str(); 01009 } 01010 01011 01012 //---------------------------------------------------------------------------- 01013 const char *MummySettings::GetGroup() 01014 { 01015 return this->Internals->Group.c_str(); 01016 } 01017 01018 01019 //---------------------------------------------------------------------------- 01020 const char *MummySettings::GetHeader() 01021 { 01022 return this->Internals->Header.c_str(); 01023 } 01024 01025 01026 //---------------------------------------------------------------------------- 01027 const char *MummySettings::GetPackage() 01028 { 01029 return this->Internals->Package.c_str(); 01030 } 01031 01032 01033 //---------------------------------------------------------------------------- 01034 const char *MummySettings::GetPackageVersion() 01035 { 01036 return this->Internals->PackageVersion.c_str(); 01037 } 01038 01039 01040 //---------------------------------------------------------------------------- 01041 bool MummySettings::ShouldRun() 01042 { 01043 return this->Internals->Run; 01044 } 01045 01046 01047 //---------------------------------------------------------------------------- 01048 bool MummySettings::GetVerbose() 01049 { 01050 return this->Internals->Verbose; 01051 } 01052 01053 01054 //---------------------------------------------------------------------------- 01055 gxsys_stl::string MummySettings::GetCsharpFileName(const cable::Class* c) 01056 { 01057 gxsys_stl::string s(this->GetCsharpFileName()); 01058 01059 if (s == "") 01060 { 01061 s = c->GetName(); 01062 s += ".cs"; 01063 } 01064 01065 return s; 01066 } 01067 01068 01069 //---------------------------------------------------------------------------- 01070 gxsys_stl::string MummySettings::GetExportLayerFileName(const cable::Class* c) 01071 { 01072 gxsys_stl::string s(this->GetExportLayerFileName()); 01073 01074 if (s == "") 01075 { 01076 s = c->GetName(); 01077 s += "EL.cxx"; 01078 } 01079 01080 return s; 01081 } 01082 01083 01084 //---------------------------------------------------------------------------- 01085 gxsys_stl::string MummySettings::GetCsharpUnitTestFileName(const cable::Class* c) 01086 { 01087 gxsys_stl::string s(this->GetCsharpUnitTestFileName()); 01088 01089 if (s == "") 01090 { 01091 s = c->GetName(); 01092 s += "UnitTest.cs"; 01093 } 01094 01095 return s; 01096 } 01097 01098 01099 //---------------------------------------------------------------------------- 01100 gxsys_stl::string MummySettings::GetCsharpConstructorModifier(const cable::Class* c) 01101 { 01102 gxsys_stl::string s; 01103 ClassWrappingSettings cws; 01104 01105 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01106 { 01107 s = cws.csharpConstructorModifier; 01108 } 01109 else 01110 { 01111 s = "ERROR_NoCsharpConstructorModifier"; 01112 LogError(me_NoClassWrappingSettings, 01113 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01114 } 01115 01116 return s; 01117 } 01118 01119 01120 //---------------------------------------------------------------------------- 01121 gxsys_stl::string MummySettings::GetFactoryMethod(const cable::Class* c) 01122 { 01123 gxsys_stl::string s; 01124 ClassWrappingSettings cws; 01125 01126 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01127 { 01128 s = cws.defaultFactoryMethod; 01129 } 01130 else 01131 { 01132 s = "ERROR_NoFactoryMethod"; 01133 LogError(me_NoClassWrappingSettings, 01134 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01135 } 01136 01137 return s; 01138 } 01139 01140 01141 //---------------------------------------------------------------------------- 01142 bool MummySettings::GetEmitDefaultFactoryMethod(const cable::Class* c) 01143 { 01144 bool b = false; 01145 ClassWrappingSettings cws; 01146 01147 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01148 { 01149 b = cws.emitDefaultFactoryMethod; 01150 } 01151 else 01152 { 01153 LogError(me_NoClassWrappingSettings, 01154 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01155 } 01156 01157 return b; 01158 } 01159 01160 01161 //---------------------------------------------------------------------------- 01162 gxsys_stl::string MummySettings::GetCountedMethodsRegex(const cable::Class* c) 01163 { 01164 gxsys_stl::string s; 01165 ClassWrappingSettings cws; 01166 01167 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01168 { 01169 s = cws.countedMethodsRegex; 01170 } 01171 else 01172 { 01173 s = "ERROR_NoCountedMethodsRegex"; 01174 LogError(me_NoClassWrappingSettings, 01175 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01176 } 01177 01178 return s; 01179 } 01180 01181 01182 //---------------------------------------------------------------------------- 01183 gxsys_stl::string MummySettings::GetDisposalMethod(const cable::Class* c) 01184 { 01185 gxsys_stl::string s; 01186 ClassWrappingSettings cws; 01187 01188 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01189 { 01190 s = cws.defaultDisposalMethod; 01191 } 01192 else 01193 { 01194 s = "ERROR_NoDisposalMethod"; 01195 LogError(me_NoClassWrappingSettings, 01196 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01197 } 01198 01199 return s; 01200 } 01201 01202 01203 //---------------------------------------------------------------------------- 01204 bool MummySettings::GetUseShadow(const cable::Class* c) 01205 { 01206 bool shadow = false; 01207 ClassWrappingSettings cws; 01208 01209 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01210 { 01211 shadow = cws.shadow; 01212 } 01213 else 01214 { 01215 LogError(me_NoClassWrappingSettings, 01216 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01217 } 01218 01219 return shadow; 01220 } 01221 01222 01223 //---------------------------------------------------------------------------- 01224 gxsys_stl::string MummySettings::GetExternalHints(const cable::Class* c) 01225 { 01226 gxsys_stl::string s; 01227 ClassWrappingSettings cws; 01228 01229 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01230 { 01231 s = cws.externalHints; 01232 } 01233 else 01234 { 01235 s = "ERROR_NoExternalHints"; 01236 LogError(me_NoClassWrappingSettings, 01237 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01238 } 01239 01240 return s; 01241 } 01242 01243 01244 //---------------------------------------------------------------------------- 01245 gxsys_stl::string MummySettings::GetExtraCsharpCode(const cable::Class* c) 01246 { 01247 gxsys_stl::string s; 01248 ClassWrappingSettings cws; 01249 01250 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01251 { 01252 s = cws.extraCsharpCode; 01253 } 01254 else 01255 { 01256 s = "ERROR_NoExtraCsharpCode"; 01257 LogError(me_NoClassWrappingSettings, 01258 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01259 } 01260 01261 return s; 01262 } 01263 01264 01265 //---------------------------------------------------------------------------- 01266 gxsys_stl::string MummySettings::GetExtraExportLayerCode(const cable::Class* c) 01267 { 01268 gxsys_stl::string s; 01269 ClassWrappingSettings cws; 01270 01271 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01272 { 01273 s = cws.extraExportLayerCode; 01274 } 01275 else 01276 { 01277 s = "ERROR_NoExtraExportLayerCode"; 01278 LogError(me_NoClassWrappingSettings, 01279 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01280 } 01281 01282 return s; 01283 } 01284 01285 01286 //---------------------------------------------------------------------------- 01287 gxsys_stl::string MummySettings::GetExtraCsharpUnitTestCode(const cable::Class* c) 01288 { 01289 gxsys_stl::string s; 01290 ClassWrappingSettings cws; 01291 01292 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01293 { 01294 s = cws.extraCsharpUnitTestCode; 01295 } 01296 else 01297 { 01298 s = "ERROR_NoExtraCsharpUnitTestCode"; 01299 LogError(me_NoClassWrappingSettings, 01300 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01301 } 01302 01303 return s; 01304 } 01305 01306 01307 //---------------------------------------------------------------------------- 01308 gxsys_stl::string MummySettings::GetRegisterMethod(const cable::Class* c) 01309 { 01310 gxsys_stl::string s; 01311 ClassWrappingSettings cws; 01312 01313 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01314 { 01315 s = cws.registerMethod; 01316 } 01317 else 01318 { 01319 s = "ERROR_NoRegisterMethod"; 01320 LogError(me_NoClassWrappingSettings, 01321 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01322 } 01323 01324 return s; 01325 } 01326 01327 01328 //---------------------------------------------------------------------------- 01329 gxsys_stl::string MummySettings::GetUnRegisterMethod(const cable::Class* c) 01330 { 01331 gxsys_stl::string s; 01332 ClassWrappingSettings cws; 01333 01334 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01335 { 01336 s = cws.unRegisterMethod; 01337 } 01338 else 01339 { 01340 s = "ERROR_NoUnRegisterMethod"; 01341 LogError(me_NoClassWrappingSettings, 01342 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01343 } 01344 01345 return s; 01346 } 01347 01348 01349 //---------------------------------------------------------------------------- 01350 gxsys_stl::string MummySettings::GetRegisterBaseClass(const cable::Class* c) 01351 { 01352 gxsys_stl::string s; 01353 ClassWrappingSettings cws; 01354 01355 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01356 { 01357 s = cws.registerBaseClass; 01358 } 01359 else 01360 { 01361 s = "ERROR_NoRegisterBaseClass"; 01362 LogError(me_NoClassWrappingSettings, 01363 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01364 } 01365 01366 return s; 01367 } 01368 01369 01370 //---------------------------------------------------------------------------- 01371 gxsys_stl::string MummySettings::GetRegisterInclude(const cable::Class* c) 01372 { 01373 gxsys_stl::string s; 01374 ClassWrappingSettings cws; 01375 01376 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01377 { 01378 s = cws.registerInclude; 01379 } 01380 else 01381 { 01382 s = "ERROR_NoRegisterInclude"; 01383 LogError(me_NoClassWrappingSettings, 01384 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01385 } 01386 01387 return s; 01388 } 01389 01390 01391 //---------------------------------------------------------------------------- 01392 bool MummySettings::GetPartialClass(const cable::Class* c) 01393 { 01394 bool partial = false; 01395 ClassWrappingSettings cws; 01396 01397 if (FindClassWrappingSettings(GetFullyQualifiedNameForCPlusPlus(c).c_str(), &cws)) 01398 { 01399 partial = cws.partialClass; 01400 } 01401 else 01402 { 01403 LogError(me_NoClassWrappingSettings, 01404 << "Could not find class wrapping settings for class '" << GetFullyQualifiedNameForCPlusPlus(c).c_str() << "'"); 01405 } 01406 01407 return partial; 01408 }