(file) Return to cimmofSourceConsumer.cpp CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Compiler / Attic

Diff for /pegasus/src/Pegasus/Compiler/Attic/cimmofSourceConsumer.cpp between version 1.1 and 1.1.2.1

version 1.1, 2007/09/28 02:34:14 version 1.1.2.1, 2007/09/28 02:34:14
Line 0 
Line 1 
   //%2006////////////////////////////////////////////////////////////////////////
   //
   // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
   // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
   //
   // Permission is hereby granted, free of charge, to any person obtaining a copy
   // of this software and associated documentation files (the "Software"), to
   // deal in the Software without restriction, including without limitation the
   // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   // sell copies of the Software, and to permit persons to whom the Software is
   // furnished to do so, subject to the following conditions:
   //
   // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
   // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
   // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
   // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
   // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
   // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
   // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
   // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   //
   //
   //%/////////////////////////////////////////////////////////////////////////////
   
   #include <cstdio>
   #include <cstdarg>
   #include <cctype>
   #include <Pegasus/Common/System.h>
   #include <Pegasus/Repository/SourceTypes.h>
   #include "cimmofSourceConsumer.h"
   
   PEGASUS_USING_STD;
   
   PEGASUS_NAMESPACE_BEGIN
   
   //==============================================================================
   //
   // Local routines:
   //
   //==============================================================================
   
   static size_t _indent = 0;
   
   class Str
   {
   public:
       Str(const String& s) : _cstr(s.getCString()) { }
       Str(const CIMName& n) : _cstr(n.getString().getCString()) { }
       Str(const CIMNamespaceName& n) : _cstr(n.getString().getCString()) { }
       Str(const Exception& e) : _cstr(e.getMessage().getCString()) { }
       Str(const CIMDateTime& x) : _cstr(x.toString().getCString()) { }
       Str(const CIMObjectPath& x) : _cstr(x.toString().getCString()) { }
       const char* operator*() const { return (const char*)_cstr; }
       operator const char*() const { return (const char*)_cstr; }
   private:
       CString _cstr;
   };
   
   static void _vout(FILE* os, const char* format, va_list ap)
   {
       for (size_t i = 0; i < _indent; i++)
           fprintf(os, "    ");
   
       vfprintf(os, format, ap);
   }
   
   PEGASUS_FORMAT(2, 3)
   static void _throw(CIMStatusCode code, const char* format, ...)
   {
       char buffer[4096];
   
       va_list ap;
       va_start(ap, format);
       vsprintf(buffer, format, ap);
       va_end(ap);
       throw CIMException(code, format);
   }
   
   static void _line(FILE* os)
   {
       fprintf(os, "//");
   
       for (size_t i = 0; i < 78; i++)
           fputc('=', os);
   
       fputc('\n', os);
   }
   
   PEGASUS_FORMAT(2, 3)
   static void _box(FILE* os, const char* format, ...)
   {
       _line(os);
   
       fprintf(os, "//\n");
   
       fprintf(os, "// ");
   
       va_list ap;
       va_start(ap, format);
       vfprintf(os, format, ap);
       va_end(ap);
   
       fputc('\n', os);
       fprintf(os, "//\n");
   
       _line(os);
   }
   
   static void _writeHeaderFile()
   {
       const char text[] =
           "#ifndef _repository_h\n"
           "#define _repository_h\n"
           "\n"
           "#include <Pegasus/Repository/SourceTypes.h>\n"
           "\n"
           "PEGASUS_NAMESPACE_BEGIN\n"
           "\n"
           "extern SourceRepository* source_repository;\n"
           "\n"
           "PEGASUS_NAMESPACE_END\n"
           "\n"
           "#endif /* _repository_h */\n"
           ;
   
       const char PATH[] = "repository.h";
       FILE* os = fopen(PATH, "wb");
   
       if (!os)
       {
           fprintf(stderr, "cimmofl: failed to open \"%s\" for write\n", PATH);
           exit(1);
       }
   
       size_t n = sizeof(text) - 1;
   
       if (fwrite(text, 1, n, os) != n)
       {
           fprintf(stderr, "cimmofl: failed to write\"%s\"\n", PATH);
           exit(1);
       }
   
       fclose(os);
   }
   
   static String _makeIdent(const String& str)
   {
       // Build a legal C identifier from str. Translate all illegal characters
       // to underscores.
   
       String r;
   
       for (Uint32 i = 0; i < str.size(); i++)
       {
           Uint16 c = str[i];
   
           if (c < 127 && (isalnum(c) || c == '_'))
               r.append(c);
           else
               r.append('_');
       }
   
       return r;
   }
   
   
   static const char* _typeNames[] =
   {
       "CIMTYPE_BOOLEAN",
       "CIMTYPE_UINT8",
       "CIMTYPE_SINT8",
       "CIMTYPE_UINT16",
       "CIMTYPE_SINT16",
       "CIMTYPE_UINT32",
       "CIMTYPE_SINT32",
       "CIMTYPE_UINT64",
       "CIMTYPE_SINT64",
       "CIMTYPE_REAL32",
       "CIMTYPE_REAL64",
       "CIMTYPE_CHAR16",
       "CIMTYPE_STRING",
       "CIMTYPE_DATETIME",
       "CIMTYPE_REFERENCE",
       "CIMTYPE_OBJECT",
       "CIMTYPE_INSTANCE",
   };
   
   //==============================================================================
   //
   // cimmofSourceConsumer
   //
   //==============================================================================
   
   cimmofSourceConsumer::cimmofSourceConsumer() : _os(0)
   {
   }
   
   cimmofSourceConsumer::~cimmofSourceConsumer()
   {
   }
   
   void cimmofSourceConsumer::addClass(
       const CIMNamespaceName& nameSpace,
       CIMClass& cimClass)
   {
       if (_findClass(nameSpace, cimClass.getClassName()) != PEG_NOT_FOUND)
       {
           _throw(CIM_ERR_ALREADY_EXISTS, "class already defined: %s:%s",
               *Str(nameSpace), *Str(cimClass.getClassName()));
       }
   
       _classes.append(Class(nameSpace, cimClass));
   }
   
   void cimmofSourceConsumer::addQualifier(
       const CIMNamespaceName& nameSpace,
       CIMQualifierDecl& cimQualifierDecl)
   {
       if (_findQualifier(nameSpace, cimQualifierDecl.getName()) != PEG_NOT_FOUND)
       {
           _throw(CIM_ERR_ALREADY_EXISTS, "qualifier already defined: %s:%s",
               *Str(nameSpace), *Str(cimQualifierDecl.getName()));
       }
   
       _qualifiers.append(Qualifier(nameSpace, cimQualifierDecl));
   }
   
   void cimmofSourceConsumer::addInstance(
       const CIMNamespaceName& nameSpace,
       CIMInstance& instance)
   {
       // Ignore all instances!
   }
   
   CIMQualifierDecl cimmofSourceConsumer::getQualifierDecl(
       const CIMNamespaceName& nameSpace,
       const CIMName& qualifierName)
   {
       Uint32 pos = _findQualifier(nameSpace, qualifierName);
   
       if (pos == PEG_NOT_FOUND)
       {
           _throw(CIM_ERR_NOT_FOUND,
               "undefined qualifier: %s:%s", *Str(nameSpace), *Str(qualifierName));
       }
   
       return _qualifiers[pos].second;
   }
   
   CIMClass cimmofSourceConsumer::getClass(
       const CIMNamespaceName& nameSpace,
       const CIMName& className)
   {
       Uint32 pos = _findClass(nameSpace, className);
   
       if (pos == PEG_NOT_FOUND)
       {
           _throw(CIM_ERR_NOT_FOUND,
               "undefined class: %s:%s", *Str(nameSpace), *Str(className));
       }
   
       return _classes[pos].second;
   }
   
   void cimmofSourceConsumer::modifyClass(
       const CIMNamespaceName& nameSpace,
       CIMClass& cimClass)
   {
       Uint32 pos = _findClass(nameSpace, cimClass.getClassName());
   
       if (pos == PEG_NOT_FOUND)
       {
           _throw(CIM_ERR_NOT_FOUND, "undefined class: %s:%s",
               *Str(nameSpace), *Str(cimClass.getClassName()));
       }
   
       _classes[pos].second = cimClass;
   }
   
   void cimmofSourceConsumer::createNameSpace(
       const CIMNamespaceName& nameSpace)
   {
       if (_findNameSpace(nameSpace) != PEG_NOT_FOUND)
       {
           _throw(CIM_ERR_ALREADY_EXISTS, "namespace already exists: %s",
               *Str(nameSpace));
       }
   
       _nameSpaces.append(nameSpace.getString());
   }
   
   void cimmofSourceConsumer::start()
   {
   }
   
   void cimmofSourceConsumer::finish()
   {
       // Write header file:
   
       _writeHeaderFile();
   
       // Open source file:
   
       const char PATH[] = "repository.cpp";
       _os = fopen(PATH, "wb");
   
       if (!_os)
       {
           fprintf(stderr, "cimmofl: failed to open \"%s\" for write\n", PATH);
           exit(1);
       }
   
       // Write prologue:
   
       _writeSourcePrologue();
   
       // Write each namespace:
   
       for (Uint32 i = 0; i < _nameSpaces.size(); i++)
           _writeNameSpace(_nameSpaces[i]);
   
       // Write epilogue:
   
       _writeSourceEpilogue();
   }
   
   Uint32 cimmofSourceConsumer::_findNameSpace(
       const CIMNamespaceName& nameSpace) const
   {
       for (Uint32 i = 0; i < _nameSpaces.size(); i++)
       {
           if (_nameSpaces[i] == nameSpace)
               return i;
       }
   
       // Not found!
       return PEG_NOT_FOUND;
   }
   
   Uint32 cimmofSourceConsumer::_findClass(
       const CIMNamespaceName& nameSpace,
       const CIMName& className) const
   {
       for (Uint32 i = 0; i < _classes.size(); i++)
       {
           const Class& c = _classes[i];
   
           if (c.first == nameSpace && c.second.getClassName() == className)
               return i;
       }
   
       // Not found!
       return PEG_NOT_FOUND;
   }
   
   Uint32 cimmofSourceConsumer::_findQualifier(
       const CIMNamespaceName& nameSpace,
       const CIMName& qualifierName) const
   {
       for (Uint32 i = 0; i < _qualifiers.size(); i++)
       {
           const Qualifier& q = _qualifiers[i];
   
           if (q.first == nameSpace && q.second.getName() == qualifierName)
               return i;
       }
   
       // Not found!
       return PEG_NOT_FOUND;
   }
   
   void cimmofSourceConsumer::_writeSourcePrologue()
   {
       _outn("#include \"repository.h\"");
       _nl();
       _outn("PEGASUS_NAMESPACE_BEGIN");
       _nl();
   }
   
   void cimmofSourceConsumer::_writeSourceEpilogue()
   {
       _outn("PEGASUS_NAMESPACE_END");
   }
   
   template<class C>
   static void _writeFlags(
       FILE* os,
       const C& c,
       bool isProperty,
       bool isParameter)
   {
       // Build up flags mask:
   
       Uint32 flags = 0;
   
       if (isProperty)
           flags |= PEGASUS_FLAG_READ;
   
       if (isParameter)
           flags |= PEGASUS_FLAG_IN;
   
       for (Uint32 i = 0; i < c.getQualifierCount(); i++)
       {
           CIMConstQualifier cq = c.getQualifier(i);
           const CIMName& qn = cq.getName();
   
           if (cq.getType() != CIMTYPE_BOOLEAN || cq.isArray())
               continue;
   
           Boolean x;
           cq.getValue().get(x);
   
   
           if (System::strcasecmp(*Str(qn), "KEY") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_KEY;
               else
                   flags &= ~PEGASUS_FLAG_KEY;
           }
           if (System::strcasecmp(*Str(qn), "IN") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_IN;
               else
                   flags &= ~PEGASUS_FLAG_IN;
           }
           if (System::strcasecmp(*Str(qn), "OUT") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_OUT;
               else
                   flags &= ~PEGASUS_FLAG_OUT;
           }
           if (System::strcasecmp(*Str(qn), "ABSTRACT") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_ABSTRACT;
               else
                   flags &= ~PEGASUS_FLAG_ABSTRACT;
           }
           if (System::strcasecmp(*Str(qn), "AGGREGATE") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_AGGREGATE;
               else
                   flags &= ~PEGASUS_FLAG_AGGREGATE;
           }
           if (System::strcasecmp(*Str(qn), "AGGREGATION") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_AGGREGATION;
               else
                   flags &= ~PEGASUS_FLAG_AGGREGATION;
           }
           if (System::strcasecmp(*Str(qn), "COUNTER") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_COUNTER;
               else
                   flags &= ~PEGASUS_FLAG_COUNTER;
           }
           if (System::strcasecmp(*Str(qn), "DELETE") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_DELETE;
               else
                   flags &= ~PEGASUS_FLAG_DELETE;
           }
           if (System::strcasecmp(*Str(qn), "DN") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_DN;
               else
                   flags &= ~PEGASUS_FLAG_DN;
           }
           if (System::strcasecmp(*Str(qn), "EMBEDDEDOBJECT") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_EMBEDDEDOBJECT;
               else
                   flags &= ~PEGASUS_FLAG_EMBEDDEDOBJECT;
           }
           if (System::strcasecmp(*Str(qn), "EXPENSIVE") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_EXPENSIVE;
               else
                   flags &= ~PEGASUS_FLAG_EXPENSIVE;
           }
           if (System::strcasecmp(*Str(qn), "EXPERIMENTAL") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_EXPERIMENTAL;
               else
                   flags &= ~PEGASUS_FLAG_EXPERIMENTAL;
           }
           if (System::strcasecmp(*Str(qn), "GAUGE") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_GAUGE;
               else
                   flags &= ~PEGASUS_FLAG_GAUGE;
           }
           if (System::strcasecmp(*Str(qn), "IFDELETED") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_IFDELETED;
               else
                   flags &= ~PEGASUS_FLAG_IFDELETED;
           }
           if (System::strcasecmp(*Str(qn), "INVISIBLE") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_INVISIBLE;
               else
                   flags &= ~PEGASUS_FLAG_INVISIBLE;
           }
           if (System::strcasecmp(*Str(qn), "LARGE") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_LARGE;
               else
                   flags &= ~PEGASUS_FLAG_LARGE;
           }
           if (System::strcasecmp(*Str(qn), "OCTETSTRING") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_OCTETSTRING;
               else
                   flags &= ~PEGASUS_FLAG_OCTETSTRING;
           }
           if (System::strcasecmp(*Str(qn), "READ") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_READ;
               else
                   flags &= ~PEGASUS_FLAG_READ;
           }
           if (System::strcasecmp(*Str(qn), "REQUIRED") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_REQUIRED;
               else
                   flags &= ~PEGASUS_FLAG_REQUIRED;
           }
           if (System::strcasecmp(*Str(qn), "STATIC") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_STATIC;
               else
                   flags &= ~PEGASUS_FLAG_STATIC;
           }
           if (System::strcasecmp(*Str(qn), "TERMINAL") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_TERMINAL;
               else
                   flags &= ~PEGASUS_FLAG_TERMINAL;
           }
           if (System::strcasecmp(*Str(qn), "WEAK") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_WEAK;
               else
                   flags &= ~PEGASUS_FLAG_WEAK;
           }
           if (System::strcasecmp(*Str(qn), "WRITE") == 0)
           {
               if (x)
                   flags |= PEGASUS_FLAG_WRITE;
               else
                   flags &= ~PEGASUS_FLAG_WRITE;
           }
       }
   
       // Write flags mask:
   
       if (flags & PEGASUS_FLAG_KEY)
           fprintf(os, "|PEGASUS_FLAG_KEY");
       if (flags && (flags & PEGASUS_FLAG_IN))
           fprintf(os, "|PEGASUS_FLAG_IN");
       if (flags && (flags & PEGASUS_FLAG_OUT))
           fprintf(os, "|PEGASUS_FLAG_OUT");
       if (flags & PEGASUS_FLAG_ABSTRACT)
           fprintf(os, "|PEGASUS_FLAG_ABSTRACT");
       if (flags & PEGASUS_FLAG_AGGREGATE)
           fprintf(os, "|PEGASUS_FLAG_AGGREGATE");
       if (flags & PEGASUS_FLAG_AGGREGATION)
           fprintf(os, "|PEGASUS_FLAG_AGGREGATION");
       if (flags & PEGASUS_FLAG_COUNTER)
           fprintf(os, "|PEGASUS_FLAG_COUNTER");
       if (flags & PEGASUS_FLAG_DELETE)
           fprintf(os, "|PEGASUS_FLAG_DELETE");
       if (flags & PEGASUS_FLAG_DN)
           fprintf(os, "|PEGASUS_FLAG_DN");
       if (flags & PEGASUS_FLAG_EMBEDDEDOBJECT)
           fprintf(os, "|PEGASUS_FLAG_EMBEDDEDOBJECT");
       if (flags & PEGASUS_FLAG_EXPENSIVE)
           fprintf(os, "|PEGASUS_FLAG_EXPENSIVE");
       if (flags & PEGASUS_FLAG_EXPERIMENTAL)
           fprintf(os, "|PEGASUS_FLAG_EXPERIMENTAL");
       if (flags & PEGASUS_FLAG_GAUGE)
           fprintf(os, "|PEGASUS_FLAG_GAUGE");
       if (flags & PEGASUS_FLAG_IFDELETED)
           fprintf(os, "|PEGASUS_FLAG_IFDELETED");
       if (flags & PEGASUS_FLAG_INVISIBLE)
           fprintf(os, "|PEGASUS_FLAG_INVISIBLE");
       if (flags & PEGASUS_FLAG_LARGE)
           fprintf(os, "|PEGASUS_FLAG_LARGE");
       if (flags & PEGASUS_FLAG_OCTETSTRING)
           fprintf(os, "|PEGASUS_FLAG_OCTETSTRING");
       if (flags & PEGASUS_FLAG_READ)
           fprintf(os, "|PEGASUS_FLAG_READ");
       if (flags & PEGASUS_FLAG_REQUIRED)
           fprintf(os, "|PEGASUS_FLAG_REQUIRED");
       if (flags & PEGASUS_FLAG_STATIC)
           fprintf(os, "|PEGASUS_FLAG_STATIC");
       if (flags & PEGASUS_FLAG_TERMINAL)
           fprintf(os, "|PEGASUS_FLAG_TERMINAL");
       if (flags & PEGASUS_FLAG_WEAK)
           fprintf(os, "|PEGASUS_FLAG_WEAK");
       if (flags & PEGASUS_FLAG_WRITE)
           fprintf(os, "|PEGASUS_FLAG_WRITE");
   }
   
   void cimmofSourceConsumer::_writeProperty(
       const CIMNamespaceName& nameSpace,
       const CIMName& cn,
       const CIMConstProperty& cp)
   {
       String ns = _makeIdent(nameSpace.getString());
       CIMName pn = cp.getName();
       CIMType ct = cp.getType();
   
       _outn("static SourceProperty _%s__%s_%s =", *Str(ns), *Str(cn), *Str(pn));
       _outn("{");
       _indent++;
   
       // SourceProperty.flags:
   
       _out("PEGASUS_FLAG_PROPERTY");
       _writeFlags(_os, cp, true, false);
       fprintf(_os, ",\n");
   
       // SourceProperty.name:
   
       _outn("\"%s\", /* name */", *Str(pn));
   
       // SourceProperty.type:
   
       _outn("%s, /* type */", _typeNames[ct]);
   
       // SourceProperty.subscript:
   
       if (cp.isArray())
       {
           Uint32 n = cp.getArraySize();
           _outn("%u, /* subscript */", n);
       }
       else
       {
           _outn("-1, /* subscript */");
       }
   
       // SourceProperty.refClass:
   
       if (ct == CIMTYPE_REFERENCE)
       {
           const CIMName& rcn = cp.getReferenceClassName();
           _outn("&_%s__%s, /* refClass */\n", *Str(ns), *Str(rcn));
       }
       else
       {
           _outn("0, /* refClass */");
       }
   
       _indent--;
       _outn("};");
       _nl();
   
       // ATTN: define qualifiers:
   }
   
   static bool _testBooleanQualifier(const CIMClass& cc, const CIMName& name)
   {
       Uint32 pos = cc.findQualifier(name);
   
       if (pos == PEG_NOT_FOUND)
           return false;
   
       CIMConstQualifier cq = cc.getQualifier(pos);
   
       if (cq.getType() != CIMTYPE_BOOLEAN || cq.isArray())
           return false;
   
       Boolean x;
       cq.getValue().get(x);
       return x;
   }
   
   void cimmofSourceConsumer::_writeClass(
       const CIMNamespaceName& nameSpace,
       const CIMClass& cc)
   {
       String ns = _makeIdent(nameSpace.getString());
       CIMName cn = cc.getClassName();
   
       // Write comment:
   
       _box(_os, "Class: %s:%s", *Str(nameSpace), *Str(cn));
       _nl();
   
       // Write property definitions:
   
       Array<CIMName> featureNames;
   
       for (Uint32 i = 0; i < cc.getPropertyCount(); i++)
       {
           CIMConstProperty cp = cc.getProperty(i);
           _writeProperty(nameSpace, cc.getClassName(), cp);
           featureNames.append(cp.getName());
       }
   
       // Write method definitions:
       // ATTN:
   
       // Write feature array:
   
       _outn("static SourceFeature* _%s__%s_features[] =", *Str(ns), *Str(cn));
       _outn("{");
       _indent++;
   
       for (Uint32 i = 0; i < featureNames.size(); i++)
       {
           const CIMName& fn = featureNames[i];
           _outn("(SourceFeature*)&_%s__%s_%s,", *Str(ns), *Str(cn), *Str(fn));
       }
   
       _outn("0,");
       _indent--;
       _outn("};");
       _nl();
   
       // Class header:
   
       _outn("static SourceClass _%s__%s =", *Str(ns), *Str(cn));
       _outn("{");
       _indent++;
   
       // SourceClass.flags:
   
       if (_testBooleanQualifier(cc, "Association"))
           _out("PEGASUS_FLAG_ASSOCIATION");
       else if (_testBooleanQualifier(cc, "Indication"))
           _out("PEGASUS_FLAG_INDICATION");
       else
           _out("PEGASUS_FLAG_CLASS");
   
       _writeFlags(_os, cc, false, false);
       fprintf(_os, ",\n");
   
       // SourceClass.name:
   
       _outn("\"%s\", /* name */", *Str(cn));
   
       // SourceClass.super:
   
       const CIMName& scn = cc.getSuperClassName();
   
       if (scn.isNull())
           _outn("0, /* super */");
       else
           _outn("&_%s__%s, /* super */", *Str(ns), *Str(scn));
   
       // SourceClass.features:
   
       _outn("_%s__%s_features,", *Str(ns), *Str(cn));
   
       // Class footer:
   
       _indent--;
       _outn("};");
       _nl();
   }
   
   void cimmofSourceConsumer::_writeNameSpace(const CIMNamespaceName& nameSpace)
   {
       for (Uint32 i = 0; i < _classes.size(); i++)
       {
           const Class& c = _classes[i];
   
           if (c.first == nameSpace)
               _writeClass(c.first, c.second);
       }
   }
   
   PEGASUS_FORMAT(2, 3)
   void cimmofSourceConsumer::_out(const char* format, ...)
   {
       va_list ap;
       va_start(ap, format);
       _vout(_os, format, ap);
       va_end(ap);
   }
   
   PEGASUS_FORMAT(2, 3)
   void cimmofSourceConsumer::_outn(const char* format, ...)
   {
       va_list ap;
       va_start(ap, format);
       _vout(_os, format, ap);
       va_end(ap);
       fputc('\n', _os);
   }
   
   void cimmofSourceConsumer::_nl()
   {
       _out("\n");
   }
   
   PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.1.2.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2