mummy  1.0.2
MummySettings.cxx
Go to the documentation of this file.
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 }