OW_MOFCIMOMVisitor.cpp

Go to the documentation of this file.
00001 /*******************************************************************************
00002 * Copyright (C) 2001-2004 Vintela, Inc. All rights reserved.
00003 *
00004 * Redistribution and use in source and binary forms, with or without
00005 * modification, are permitted provided that the following conditions are met:
00006 *
00007 *  - Redistributions of source code must retain the above copyright notice,
00008 *    this list of conditions and the following disclaimer.
00009 *
00010 *  - Redistributions in binary form must reproduce the above copyright notice,
00011 *    this list of conditions and the following disclaimer in the documentation
00012 *    and/or other materials provided with the distribution.
00013 *
00014 *  - Neither the name of Vintela, Inc. nor the names of its
00015 *    contributors may be used to endorse or promote products derived from this
00016 *    software without specific prior written permission.
00017 *
00018 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
00019 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00020 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00021 * ARE DISCLAIMED. IN NO EVENT SHALL Vintela, Inc. OR THE CONTRIBUTORS
00022 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
00023 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
00024 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
00025 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
00026 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
00027 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00028 * POSSIBILITY OF SUCH DAMAGE.
00029 *******************************************************************************/
00030 
00035 #include "OW_config.h"
00036 #include "OW_MOFGrammar.hpp"
00037 #include "OW_MOFCIMOMVisitor.hpp"
00038 #include "OW_CIMValueCast.hpp"
00039 #include "OW_Format.hpp"
00040 #include "OW_MOFCompiler.hpp"
00041 #include "OW_CIMFlavor.hpp"
00042 #include "OW_CIMScope.hpp"
00043 #include "OW_CIMObjectPath.hpp"
00044 #include "OW_CIMException.hpp"
00045 #include "OW_CIMNameSpaceUtils.hpp"
00046 #include "OW_FileSystem.hpp"
00047 #include <assert.h>
00048 
00049 namespace OW_NAMESPACE
00050 {
00051 
00052 namespace MOF
00053 {
00054 
00055 using namespace WBEMFlags;
00056 CIMOMVisitor::CIMOMVisitor(const CIMOMHandleIFCRef& handle, 
00057    const Compiler::Options& opts,
00058    const ParserErrorHandlerIFCRef& _theErrorHandler)
00059 : m_curValue(CIMNULL)
00060 , m_hdl(handle)
00061 , m_rephdl(handle.cast_to<RepositoryCIMOMHandle>())
00062 , theErrorHandler(_theErrorHandler)
00063 , m_opts(opts)
00064 , m_namespace(opts.m_namespace)
00065 {
00066 }
00067 CIMOMVisitor::~CIMOMVisitor()
00068 {
00069 }
00070 void CIMOMVisitor::VisitMOFSpecification( const MOFSpecification *pMOFSpecification )
00071 {
00072    for ( List<MOFProduction *>::const_iterator i = pMOFSpecification->pMOFProduction->begin();
00073        i != pMOFSpecification->pMOFProduction->end();
00074        ++i )
00075       (*i)->Accept( this );
00076 }
00077 void CIMOMVisitor::VisitMOFProductionCompilerDirective( const MOFProductionCompilerDirective *pMOFProductionCompilerDirective )
00078 {
00079    pMOFProductionCompilerDirective->pCompilerDirective->Accept( this );
00080 }
00081 void CIMOMVisitor::VisitMOFProductionClassDeclaration( const MOFProductionClassDeclaration *pMOFProductionClassDeclaration )
00082 {
00083    pMOFProductionClassDeclaration->pClassDeclaration->Accept( this );
00084 }
00085 void CIMOMVisitor::VisitMOFProductionAssocDeclaration( const MOFProductionAssocDeclaration *pMOFProductionAssocDeclaration )
00086 {
00087    pMOFProductionAssocDeclaration->pAssocDeclaration->Accept( this );
00088 }
00089 void CIMOMVisitor::VisitMOFProductionIndicDeclaration( const MOFProductionIndicDeclaration *pMOFProductionIndicDeclaration )
00090 {
00091    pMOFProductionIndicDeclaration->pIndicDeclaration->Accept( this );
00092 }
00093 void CIMOMVisitor::VisitMOFProductionQualifierDeclaration( const MOFProductionQualifierDeclaration *pMOFProductionQualifierDeclaration )
00094 {
00095    pMOFProductionQualifierDeclaration->pQualifierDeclaration->Accept( this );
00096 }
00097 void CIMOMVisitor::VisitMOFProductionInstanceDeclaration( const MOFProductionInstanceDeclaration *pMOFProductionInstanceDeclaration )
00098 {
00099    pMOFProductionInstanceDeclaration->pInstanceDeclaration->Accept( this );
00100 }
00101 void CIMOMVisitor::VisitCompilerDirective( const CompilerDirective *pCompilerDirective )
00102 {
00103    //pCompilerDirective->pPragmaName->Accept( this );
00104    //pCompilerDirective->pPragmaParameter->Accept( this );
00105    if (pCompilerDirective->pPragmaName->pPragmaName->equalsIgnoreCase("include"))
00106    {
00107       // this should be taken care of in the parser, so just ignore it.
00108    }
00109    else if (pCompilerDirective->pPragmaName->pPragmaName->equalsIgnoreCase("instancelocale"))
00110    {
00111       theErrorHandler->recoverableError("#pragma instancelocale is unimplemented", pCompilerDirective->theLineInfo);
00112       m_instanceLocale = Compiler::fixParsedString(*pCompilerDirective->pPragmaParameter->pPragmaParameter);
00113    }
00114    else if (pCompilerDirective->pPragmaName->pPragmaName->equalsIgnoreCase("locale"))
00115    {
00116       m_locale = Compiler::fixParsedString(*pCompilerDirective->pPragmaParameter->pPragmaParameter);
00117    }
00118    else if (pCompilerDirective->pPragmaName->pPragmaName->equalsIgnoreCase("namespace"))
00119    {
00120       m_namespace = Compiler::fixParsedString(*pCompilerDirective->pPragmaParameter->pPragmaParameter);
00121    }
00122    else if (pCompilerDirective->pPragmaName->pPragmaName->equalsIgnoreCase("nonlocal"))
00123    {
00124       theErrorHandler->recoverableError("#pragma nonlocal is unimplemented", pCompilerDirective->theLineInfo);
00125       if (!m_nonLocalType.empty())
00126       {
00127          // report an error, both nonlocal and nonlocaltype cannot be set.
00128          theErrorHandler->recoverableError("nonlocal and nonlocaltype pragmas can't both be set, pragma nonlocal ignored",
00129             pCompilerDirective->theLineInfo);
00130       }
00131       m_nonLocal = Compiler::fixParsedString(*pCompilerDirective->pPragmaParameter->pPragmaParameter);
00132    }
00133    else if (pCompilerDirective->pPragmaName->pPragmaName->equalsIgnoreCase("nonlocaltype"))
00134    {
00135       theErrorHandler->recoverableError("#pragma nonlocaltype is unimplemented", pCompilerDirective->theLineInfo);
00136       if (!m_nonLocal.empty())
00137       {
00138          // report an error, both nonlocal and nonlocaltype cannot be set.
00139          theErrorHandler->recoverableError("nonlocal and nonlocaltype pragmas can't both be set, pragma nonlocaltype ignored",
00140             pCompilerDirective->theLineInfo);
00141       }
00142       m_nonLocalType = Compiler::fixParsedString(*pCompilerDirective->pPragmaParameter->pPragmaParameter);
00143    }
00144    else if (pCompilerDirective->pPragmaName->pPragmaName->equalsIgnoreCase("source"))
00145    {
00146       theErrorHandler->recoverableError("#pragma source is unimplemented", pCompilerDirective->theLineInfo);
00147       if (!m_sourceType.empty())
00148       {
00149          // report an error, both source and sourcetype cannot be set
00150          theErrorHandler->recoverableError("source and sourcetype pragmas can't both be set, pragma source ignored",
00151             pCompilerDirective->theLineInfo);
00152       }
00153       m_source = Compiler::fixParsedString(*pCompilerDirective->pPragmaParameter->pPragmaParameter);
00154    }
00155    else if (pCompilerDirective->pPragmaName->pPragmaName->equalsIgnoreCase("sourcetype"))
00156    {
00157       theErrorHandler->recoverableError("#pragma sourcetype is unimplemented", pCompilerDirective->theLineInfo);
00158       if (!m_source.empty())
00159       {
00160          // report an error, both source and sourcetype cannot be set
00161          theErrorHandler->recoverableError("source and sourcetype pragmas can't both be set, pragma sourcetype ignored",
00162             pCompilerDirective->theLineInfo);
00163       }
00164       m_sourceType = Compiler::fixParsedString(*pCompilerDirective->pPragmaParameter->pPragmaParameter);
00165    }
00166    else
00167    {
00168       theErrorHandler->recoverableError(
00169          Format("Ignoring unknown pragma: %1",
00170             *pCompilerDirective->pPragmaName->pPragmaName).c_str(),
00171          pCompilerDirective->theLineInfo);
00172    }
00173 }
00174 void CIMOMVisitor::VisitPragmaName( const PragmaName * )
00175 {
00176    assert(0);
00177 }
00178 void CIMOMVisitor::VisitPragmaParameter( const PragmaParameter * )
00179 {
00180    assert(0);
00181 }
00182 void CIMOMVisitor::VisitClassDeclaration( const ClassDeclaration *pClassDeclaration )
00183 {
00184    m_curClass = CIMClass(*pClassDeclaration->pClassName->pClassName);
00185    if ( pClassDeclaration->pQualifier.get() != 0 )
00186    {
00187       for ( List<Qualifier *>::const_iterator i = pClassDeclaration->pQualifier->begin();
00188           i != pClassDeclaration->pQualifier->end(); ++i )
00189       {
00190          (*i)->Accept( this );
00191          if (!m_opts.m_removeDescriptions || !m_curQualifier.getName().equalsIgnoreCase(CIMQualifier::CIM_QUAL_DESCRIPTION))
00192          {
00193             m_curClass.addQualifier(m_curQualifier);
00194          }
00195       }
00196    }
00197    if ( pClassDeclaration->pAlias.get() != 0 )
00198    {
00199       theErrorHandler->recoverableError("Class aliases are deprecated per DMTF CR817", pClassDeclaration->theLineInfo);
00200       m_aliasMap[*(pClassDeclaration->pAlias->pAliasIdentifier->pAliasIdentifier)] =
00201          *(pClassDeclaration->pClassName->pClassName);
00202    }
00203    if ( pClassDeclaration->pSuperClass.get() != 0 )
00204    {
00205       m_curClass.setSuperClass(*(pClassDeclaration->pSuperClass->pClassName->pClassName));
00206    }
00207    if ( pClassDeclaration->pClassFeature.get() != 0 )
00208    {
00209       for ( List<ClassFeature *>::const_iterator i = pClassDeclaration->pClassFeature->begin();
00210           i != pClassDeclaration->pClassFeature->end();
00211           ++i )
00212       {
00213          (*i)->Accept( this );
00214       }
00215    }
00216    CIMOMprocessClass(pClassDeclaration->theLineInfo);
00217 }
00218 void CIMOMVisitor::VisitAssocDeclaration( const AssocDeclaration *pAssocDeclaration )
00219 {
00220    m_curClass = CIMClass(*pAssocDeclaration->pClassName->pClassName);
00221    CIMQualifierType qt = getQualifierType(CIMQualifier::CIM_QUAL_ASSOCIATION, pAssocDeclaration->theLineInfo);
00222    CIMQualifier q(qt);
00223    q.setValue(CIMValue(Bool(true)));
00224    m_curClass.addQualifier(q);
00225    if ( pAssocDeclaration->pQualifier.get() != 0 )
00226    {
00227       for ( List<Qualifier *>::const_iterator i = pAssocDeclaration->pQualifier->begin();
00228           i != pAssocDeclaration->pQualifier->end();
00229           ++i )
00230       {
00231          (*i)->Accept( this );
00232          if (!m_opts.m_removeDescriptions || !m_curQualifier.getName().equalsIgnoreCase(CIMQualifier::CIM_QUAL_DESCRIPTION))
00233          {
00234             m_curClass.addQualifier(m_curQualifier);
00235          }
00236       }
00237    }
00238    if ( pAssocDeclaration->pAlias.get() != 0 )
00239    {
00240       theErrorHandler->recoverableError("Class aliases are deprecated per DMTF CR817", pAssocDeclaration->theLineInfo);
00241       m_aliasMap[*(pAssocDeclaration->pAlias->pAliasIdentifier->pAliasIdentifier)] =
00242          *(pAssocDeclaration->pClassName->pClassName);
00243    }
00244    if ( pAssocDeclaration->pSuperClass.get() != 0 )
00245    {
00246       m_curClass.setSuperClass(*(pAssocDeclaration->pSuperClass->pClassName->pClassName));
00247    }
00248    if ( pAssocDeclaration->pAssociationFeature.get() != 0 )
00249    {
00250       for ( List<AssociationFeature *>::const_iterator i = pAssocDeclaration->pAssociationFeature->begin();
00251           i != pAssocDeclaration->pAssociationFeature->end();
00252           ++i )
00253       {
00254          (*i)->Accept( this );
00255       }
00256    }
00257    CIMOMprocessClass(pAssocDeclaration->theLineInfo);
00258 }
00259 void CIMOMVisitor::VisitIndicDeclaration( const IndicDeclaration *pIndicDeclaration )
00260 {
00261    m_curClass = CIMClass(*pIndicDeclaration->pClassName->pClassName);
00262    
00263    CIMQualifierType qt = getQualifierType(CIMQualifier::CIM_QUAL_INDICATION, pIndicDeclaration->theLineInfo);
00264    CIMQualifier q(qt);
00265    q.setValue(CIMValue(Bool(true)));
00266    m_curClass.addQualifier(q);
00267    if ( pIndicDeclaration->pQualifier.get() != 0 )
00268    {
00269       for ( List<Qualifier *>::const_iterator i = pIndicDeclaration->pQualifier->begin();
00270           i != pIndicDeclaration->pQualifier->end();
00271           ++i )
00272       {
00273          (*i)->Accept( this );
00274          if (!m_opts.m_removeDescriptions || !m_curQualifier.getName().equalsIgnoreCase(CIMQualifier::CIM_QUAL_DESCRIPTION))
00275          {
00276             m_curClass.addQualifier(m_curQualifier);
00277          }
00278       }
00279    }
00280    if ( pIndicDeclaration->pAlias.get() != 0 )
00281    {
00282       theErrorHandler->recoverableError("Class aliases are deprecated per DMTF CR817", pIndicDeclaration->theLineInfo);
00283       m_aliasMap[*(pIndicDeclaration->pAlias->pAliasIdentifier->pAliasIdentifier)] =
00284          *(pIndicDeclaration->pClassName->pClassName);
00285    }
00286    if ( pIndicDeclaration->pSuperClass.get() != 0 )
00287    {
00288       m_curClass.setSuperClass(*(pIndicDeclaration->pSuperClass->pClassName->pClassName));
00289    }
00290    if ( pIndicDeclaration->pClassFeature.get() != 0 )
00291    {
00292       for ( List<ClassFeature *>::const_iterator i = pIndicDeclaration->pClassFeature->begin();
00293           i != pIndicDeclaration->pClassFeature->end();
00294           ++i )
00295       {
00296          (*i)->Accept( this );
00297       }
00298    }
00299    CIMOMprocessClass(pIndicDeclaration->theLineInfo);
00300 }
00301 void CIMOMVisitor::VisitClassName( const ClassName * )
00302 {
00303    assert(0);
00304 }
00305 void CIMOMVisitor::VisitAlias( const Alias * )
00306 {
00307    assert(0);
00308 }
00309 void CIMOMVisitor::VisitAliasIdentifier( const AliasIdentifier *pAliasIdentifier )
00310 {
00311    String alias = m_aliasMap[*pAliasIdentifier->pAliasIdentifier];
00312    if (alias.empty())
00313    {
00314       theErrorHandler->recoverableError(Format("Invalid alias: %1", *pAliasIdentifier->pAliasIdentifier).c_str(),
00315          pAliasIdentifier->theLineInfo);
00316    }
00317    m_curValue = CIMValue(alias);
00318 }
00319 void CIMOMVisitor::VisitSuperClass( const SuperClass * )
00320 {
00321    assert(0);
00322 }
00323 void CIMOMVisitor::VisitClassFeaturePropertyDeclaration( const ClassFeaturePropertyDeclaration *pClassFeaturePropertyDeclaration )
00324 {
00325    pClassFeaturePropertyDeclaration->pPropertyDeclaration->Accept( this );
00326    m_curClass.addProperty(m_curProperty);
00327 }
00328 void CIMOMVisitor::VisitClassFeatureMethodDeclaration( const ClassFeatureMethodDeclaration *pClassFeatureMethodDeclaration )
00329 {
00330    pClassFeatureMethodDeclaration->pMethodDeclaration->Accept( this );
00331    m_curClass.addMethod(m_curMethod);
00332 }
00333 void CIMOMVisitor::VisitClassFeatureReferenceDeclaration( const ClassFeatureReferenceDeclaration *pClassFeatureReferenceDeclaration )
00334 {
00335    pClassFeatureReferenceDeclaration->pReferenceDeclaration->Accept( this );
00336    m_curClass.addProperty(m_curProperty);
00337 }
00338 void CIMOMVisitor::VisitAssociationFeatureClassFeature( const AssociationFeatureClassFeature *pAssociationFeatureClassFeature )
00339 {
00340    pAssociationFeatureClassFeature->pClassFeature->Accept( this );
00341 }
00342 void CIMOMVisitor::VisitQualifier( const Qualifier *pQualifier )
00343 {
00344    CIMQualifierType qt = getQualifierType(*pQualifier->pQualifierName->pQualifierName, pQualifier->theLineInfo);
00345    m_curQualifier = CIMQualifier(qt);
00346    m_curQualifier.setName(*pQualifier->pQualifierName->pQualifierName);
00347    if ( pQualifier->pQualifierParameter.get() != 0 )
00348    {
00349       pQualifier->pQualifierParameter->Accept( this );
00350       m_curQualifier.setValue(m_curValue);
00351    }
00352    else
00353    {
00354       // CIM spec 4.7: The MOF syntax allows specifying a qualifier without
00355       // an explicit value. In this case, the assumed value depends on the
00356       // qualifier type: booleans are true, numeric types are null, strings
00357       // are null and arrays are empty.
00358       if (qt.getDataType().isArrayType())
00359       {
00360          // create an empty array of the right type.  An empty String array
00361          // will cast to anything.
00362          m_curQualifier.setValue(CIMValueCast::castValueToDataType(CIMValue(StringArray()),qt.getDataType()));
00363       }
00364       else if (qt.getDataType().getType() == CIMDataType::BOOLEAN)
00365       {
00366          m_curQualifier.setValue(CIMValue(Bool(true)));
00367       }
00368       else
00369       {
00370          m_curQualifier.setValue(CIMValue(CIMNULL));
00371       }
00372    }
00373    if ( pQualifier->pFlavor.get() != 0 )
00374    {
00375       for ( List<Flavor *>::const_iterator i = pQualifier->pFlavor->begin();
00376           i != pQualifier->pFlavor->end(); ++i )
00377       {
00378          if ( (*i)->pFlavor->equalsIgnoreCase( "ENABLEOVERRIDE" ) )
00379          {
00380             m_curQualifier.addFlavor(CIMFlavor(CIMFlavor::ENABLEOVERRIDE));
00381          }
00382          else if ( (*i)->pFlavor->equalsIgnoreCase( "DISABLEOVERRIDE" ) )
00383          {
00384             m_curQualifier.addFlavor(CIMFlavor(CIMFlavor::DISABLEOVERRIDE));
00385          }
00386          else if ( (*i)->pFlavor->equalsIgnoreCase( "RESTRICTED" ) )
00387          {
00388             m_curQualifier.addFlavor(CIMFlavor(CIMFlavor::RESTRICTED));
00389          }
00390          else if ( (*i)->pFlavor->equalsIgnoreCase( "TOSUBCLASS" ) )
00391          {
00392             m_curQualifier.addFlavor(CIMFlavor(CIMFlavor::TOSUBCLASS));
00393          }
00394          else if ( (*i)->pFlavor->equalsIgnoreCase( "TRANSLATABLE" ) )
00395          {
00396             m_curQualifier.addFlavor(CIMFlavor(CIMFlavor::TRANSLATE));
00397          }
00398          else
00399          {
00400             theErrorHandler->fatalError(
00401                Format("Internal Compiler Error. Invalid flavor: %1", *(*i)->pFlavor).c_str(),
00402                (*i)->theLineInfo);
00403          }
00404       }
00405    }
00406 }
00407 void CIMOMVisitor::VisitQualifierParameterConstantValue( const QualifierParameterConstantValue *pQualifierParameterConstantValue )
00408 {
00409    pQualifierParameterConstantValue->pConstantValue->Accept( this );
00410    // Need to get the type from the CIMOM
00411    CIMDataType dt = getQualifierDataType(m_curQualifier.getName(), pQualifierParameterConstantValue->theLineInfo);
00412    // now cast the value into the correct type
00413    m_curValue = CIMValueCast::castValueToDataType(m_curValue, dt);
00414 }
00415 void CIMOMVisitor::VisitQualifierParameterArrayInitializer( const QualifierParameterArrayInitializer *pQualifierParameterArrayInitializer )
00416 {
00417    pQualifierParameterArrayInitializer->pArrayInitializer->Accept( this );
00418    // Need to get the type from the CIMOM
00419    CIMDataType dt = getQualifierDataType(m_curQualifier.getName(), pQualifierParameterArrayInitializer->theLineInfo);
00420    // now cast the value into the correct type
00421    m_curValue = CIMValueCast::castValueToDataType(m_curValue, dt);
00422 }
00423 void CIMOMVisitor::VisitFlavor( const Flavor * )
00424 {
00425    assert(0);
00426 }
00427 void CIMOMVisitor::VisitPropertyDeclaration( const PropertyDeclaration *pPropertyDeclaration )
00428 {
00429    m_curProperty = CIMProperty(*pPropertyDeclaration->pPropertyName->pPropertyName);
00430    if ( pPropertyDeclaration->pQualifier.get() != 0 )
00431    {
00432       for ( List<Qualifier *>::const_iterator i = pPropertyDeclaration->pQualifier->begin();
00433           i != pPropertyDeclaration->pQualifier->end(); ++i )
00434       {
00435          (*i)->Accept( this );
00436          if (!m_opts.m_removeDescriptions || !m_curQualifier.getName().equalsIgnoreCase(CIMQualifier::CIM_QUAL_DESCRIPTION))
00437          {
00438             m_curProperty.addQualifier(m_curQualifier);
00439          }
00440       }
00441    }
00442    Int64 arraySize = -1;
00443    if ( pPropertyDeclaration->pArray.get() != 0 )
00444    {
00445       CIMDataType dt = CIMDataType::getDataType(*pPropertyDeclaration->pDataType->pDataType);
00446       if (pPropertyDeclaration->pArray->pArray.get() != 0)
00447       {
00448          pPropertyDeclaration->pArray->pArray->Accept( this );
00449          m_curValue.get(arraySize);
00450       }
00451       dt.setToArrayType(arraySize);
00452       m_curProperty.setDataType(dt);
00453    }
00454    else
00455    {
00456       m_curProperty.setDataType(CIMDataType::getDataType(*pPropertyDeclaration->pDataType->pDataType));
00457    }
00458    if ( pPropertyDeclaration->pDefaultValue.get() != 0 )
00459    {
00460       pPropertyDeclaration->pDefaultValue->Accept( this );
00461       if ( arraySize != -1 )
00462       {
00463          if ( m_curValue.isArray() )
00464          {
00465             if ( m_curValue.getArraySize() != arraySize )
00466             {
00467                theErrorHandler->recoverableError(
00468                   Format("Array size (%1) doesn't match number of elements (%2)", arraySize, m_curValue.getArraySize()).c_str(),
00469                   pPropertyDeclaration->theLineInfo);
00470             }
00471          }
00472          else
00473          {
00474             theErrorHandler->recoverableError(
00475                "Property declared as array, but value is not an array",
00476                pPropertyDeclaration->theLineInfo);
00477          }
00478       }
00479       m_curProperty.setValue(m_curValue);
00480    }
00481 }
00482 void CIMOMVisitor::VisitReferenceDeclaration( const ReferenceDeclaration *pReferenceDeclaration )
00483 {
00484    m_curProperty = CIMProperty(*pReferenceDeclaration->pReferenceName->pReferenceName);
00485    if ( pReferenceDeclaration->pQualifier.get() != 0 )
00486    {
00487       for ( List<Qualifier *>::const_iterator i = pReferenceDeclaration->pQualifier->begin();
00488           i != pReferenceDeclaration->pQualifier->end(); ++i )
00489       {
00490          (*i)->Accept( this );
00491          if (!m_opts.m_removeDescriptions || !m_curQualifier.getName().equalsIgnoreCase(CIMQualifier::CIM_QUAL_DESCRIPTION))
00492          {
00493             m_curProperty.addQualifier(m_curQualifier);
00494          }
00495       }
00496    }
00497    CIMDataType dt(*(pReferenceDeclaration->pObjectRef->pClassName->pClassName));
00498    m_curProperty.setDataType(dt);
00499    if ( pReferenceDeclaration->pDefaultValue.get() != 0 )
00500    {
00501       pReferenceDeclaration->pDefaultValue->Accept( this );
00502       m_curProperty.setValue(m_curValue);
00503    }
00504 }
00505 void CIMOMVisitor::VisitMethodDeclaration( const MethodDeclaration *pMethodDeclaration )
00506 {
00507    m_curMethod = CIMMethod(*pMethodDeclaration->pMethodName->pMethodName);
00508    if ( pMethodDeclaration->pQualifier.get() != 0 )
00509    {
00510       for ( List<Qualifier *>::const_iterator i = pMethodDeclaration->pQualifier->begin();
00511           i != pMethodDeclaration->pQualifier->end(); ++i )
00512       {
00513          (*i)->Accept( this );
00514          if (!m_opts.m_removeDescriptions || !m_curQualifier.getName().equalsIgnoreCase(CIMQualifier::CIM_QUAL_DESCRIPTION))
00515          {
00516             m_curMethod.addQualifier(m_curQualifier);
00517          }
00518       }
00519    }
00520    CIMDataType dt = CIMDataType::getDataType(*pMethodDeclaration->pDataType->pDataType);
00521    m_curMethod.setReturnType(dt);
00522    if ( pMethodDeclaration->pParameter.get() != 0 )
00523    {
00524       CIMParameterArray params;
00525       for ( List<Parameter *>::const_iterator j = pMethodDeclaration->pParameter->begin();
00526           j != pMethodDeclaration->pParameter->end(); ++j )
00527       {
00528          (*j)->Accept( this );
00529          params.append(m_curParameter);
00530       }
00531       m_curMethod.setParameters(params);
00532    }
00533 }
00534 void CIMOMVisitor::VisitPropertyName( const PropertyName * )
00535 {
00536    assert(0);
00537 }
00538 void CIMOMVisitor::VisitReferenceName( const ReferenceName * )
00539 {
00540    assert(0);
00541 }
00542 void CIMOMVisitor::VisitMethodName( const MethodName * )
00543 {
00544    assert(0);
00545 }
00546 void CIMOMVisitor::VisitDataType( const DataType * )
00547 {
00548    assert(0);
00549 }
00550 void CIMOMVisitor::VisitObjectRef( const ObjectRef * )
00551 {
00552    assert(0);
00553 }
00554 void CIMOMVisitor::VisitParameterDataType( const ParameterDataType *pParameterDataType )
00555 {
00556    m_curParameter = CIMParameter(*pParameterDataType->pParameterName->pParameterName);
00557    if ( pParameterDataType->pQualifier.get() != 0 )
00558    {
00559       CIMQualifierArray quals;
00560       for ( List<Qualifier *>::const_iterator i = pParameterDataType->pQualifier->begin();
00561           i != pParameterDataType->pQualifier->end(); ++i )
00562       {
00563          (*i)->Accept( this );
00564          if (!m_opts.m_removeDescriptions || !m_curQualifier.getName().equalsIgnoreCase(CIMQualifier::CIM_QUAL_DESCRIPTION))
00565          {
00566             quals.append(m_curQualifier);
00567          }
00568       }
00569       m_curParameter.setQualifiers(quals);
00570    }
00571    CIMDataType dt = CIMDataType::getDataType(*pParameterDataType->pDataType->pDataType);
00572    if ( pParameterDataType->pArray.get() != 0 )
00573    {
00574       Int64 arraySize = 0;
00575       if (pParameterDataType->pArray->pArray.get() != 0)
00576       {
00577          pParameterDataType->pArray->pArray->Accept( this );
00578          m_curValue.get(arraySize);
00579       }
00580       dt.setToArrayType(arraySize);
00581    }
00582    m_curParameter.setDataType(dt);
00583 }
00584 void CIMOMVisitor::VisitParameterObjectRef( const ParameterObjectRef *pParameterObjectRef )
00585 {
00586    m_curParameter = CIMParameter(*pParameterObjectRef->pParameterName->pParameterName);
00587    if ( pParameterObjectRef->pQualifier.get() != 0 )
00588    {
00589       CIMQualifierArray quals;
00590       
00591       for ( List<Qualifier *>::const_iterator i = pParameterObjectRef->pQualifier->begin();
00592            i != pParameterObjectRef->pQualifier->end(); ++i )
00593       {
00594          (*i)->Accept( this );
00595          if (!m_opts.m_removeDescriptions || !m_curQualifier.getName().equalsIgnoreCase(CIMQualifier::CIM_QUAL_DESCRIPTION))
00596          {
00597             quals.append(m_curQualifier);
00598          }
00599       }
00600       m_curParameter.setQualifiers(quals);
00601    }
00602    CIMDataType dt(*pParameterObjectRef->pObjectRef->pClassName->pClassName);
00603    if ( pParameterObjectRef->pArray.get() != 0 )
00604    {
00605       Int64 arraySize = 0;
00606       if (pParameterObjectRef->pArray->pArray.get() != 0)
00607       {
00608          pParameterObjectRef->pArray->pArray->Accept( this );
00609          m_curValue.get(arraySize);
00610       }
00611       dt.setToArrayType(arraySize);
00612    }
00613    m_curParameter.setDataType(dt);
00614 }
00615 void CIMOMVisitor::VisitParameterName( const ParameterName * )
00616 {
00617    assert(0);
00618 }
00619 void CIMOMVisitor::VisitArray( const Array * )
00620 {
00621    assert(0);
00622 }
00623 void CIMOMVisitor::VisitDefaultValue( const DefaultValue *pDefaultValue )
00624 {
00625    pDefaultValue->pInitializer->Accept( this );
00626 }
00627 void CIMOMVisitor::VisitInitializerReferenceInitializer( const InitializerReferenceInitializer *pInitializerReferenceInitializer )
00628 {
00629    pInitializerReferenceInitializer->pReferenceInitializer->Accept( this );
00630 }
00631 void CIMOMVisitor::VisitInitializerArrayInitializer( const InitializerArrayInitializer *pInitializerArrayInitializer )
00632 {
00633    pInitializerArrayInitializer->pArrayInitializer->Accept( this );
00634 }
00635 void CIMOMVisitor::VisitInitializerConstantValue( const InitializerConstantValue *pInitializerConstantValue )
00636 {
00637    pInitializerConstantValue->pConstantValue->Accept( this );
00638 }
00639 void CIMOMVisitor::VisitArrayInitializer( const ArrayInitializer *pArrayInitializer )
00640 {
00641    CIMValueArray values;
00642    if (pArrayInitializer->pConstantValue.get() != 0)
00643    {
00644       for ( List<ConstantValue *>::const_iterator i = pArrayInitializer->pConstantValue->begin();
00645           i != pArrayInitializer->pConstantValue->end(); ++i )
00646       {
00647          (*i)->Accept( this );
00648          values.push_back(m_curValue);
00649       }
00650    }
00651    m_curValue = convertValuesIntoValueArray(values);
00652 }
00653 template <class T>
00654 CIMValue doArrayConversion( T& tempArray, const CIMValueArray& values )
00655 {
00656    for (size_t i = 0; i < values.size(); ++i)
00657    {
00658       typename T::value_type element;
00659       values[i].get(element);
00660       tempArray.push_back(element);
00661    }
00662    return CIMValue(tempArray);
00663 }
00664 CIMValue CIMOMVisitor::convertValuesIntoValueArray( const CIMValueArray& values )
00665 {
00666    if (values.size())
00667    {
00668       if (values[0].getType() == CIMDataType::BOOLEAN)
00669       {
00670          BoolArray temp;
00671          return doArrayConversion(temp, values);
00672       }
00673       else if (values[0].getType() == CIMDataType::CHAR16)
00674       {
00675          Char16Array temp;
00676          return doArrayConversion(temp, values);
00677       }
00678       else if (values[0].getType() == CIMDataType::UINT8)
00679       {
00680          UInt8Array temp;
00681          return doArrayConversion(temp, values);
00682       }
00683       else if (values[0].getType() == CIMDataType::SINT8)
00684       {
00685          Int8Array temp;
00686          return doArrayConversion(temp, values);
00687       }
00688       else if (values[0].getType() == CIMDataType::UINT16)
00689       {
00690          UInt16Array temp;
00691          return doArrayConversion(temp, values);
00692       }
00693       else if (values[0].getType() == CIMDataType::SINT16)
00694       {
00695          Int16Array temp;
00696          return doArrayConversion(temp, values);
00697       }
00698       else if (values[0].getType() == CIMDataType::UINT32)
00699       {
00700          UInt32Array temp;
00701          return doArrayConversion(temp, values);
00702       }
00703       else if (values[0].getType() == CIMDataType::SINT32)
00704       {
00705          Int32Array temp;
00706          return doArrayConversion(temp, values);
00707       }
00708       else if (values[0].getType() == CIMDataType::UINT64)
00709       {
00710          UInt64Array temp;
00711          return doArrayConversion(temp, values);
00712       }
00713       else if (values[0].getType() == CIMDataType::SINT64)
00714       {
00715          Int64Array temp;
00716          return doArrayConversion(temp, values);
00717       }
00718       else if (values[0].getType() == CIMDataType::REAL64)
00719       {
00720          Real64Array temp;
00721          return doArrayConversion(temp, values);
00722       }
00723       else if (values[0].getType() == CIMDataType::REAL32)
00724       {
00725          Real32Array temp;
00726          return doArrayConversion(temp, values);
00727       }
00728       else if (values[0].getType() == CIMDataType::STRING)
00729       {
00730          StringArray temp;
00731          return doArrayConversion(temp, values);
00732       }
00733    }
00734    return CIMValue(StringArray());
00735 }
00736 void CIMOMVisitor::VisitReferenceInitializerObjectHandle( const ReferenceInitializerObjectHandle *pReferenceInitializerObjectHandle )
00737 {
00738    pReferenceInitializerObjectHandle->pObjectHandle->Accept( this );
00739 }
00740 void CIMOMVisitor::VisitReferenceInitializerAliasIdentifier( const ReferenceInitializerAliasIdentifier *pReferenceInitializerAliasIdentifier )
00741 {
00742    pReferenceInitializerAliasIdentifier->pAliasIdentifier->Accept( this );
00743 }
00744 void CIMOMVisitor::VisitObjectHandle( const ObjectHandle *pObjectHandle )
00745 {
00746    m_curValue = CIMValue(*pObjectHandle->pObjectHandle);
00747 }
00748 void CIMOMVisitor::VisitQualifierDeclaration( const QualifierDeclaration *pQualifierDeclaration )
00749 {
00750    m_curQualifierType = CIMQualifierType(*pQualifierDeclaration->pQualifierName->pQualifierName);
00751    
00752    pQualifierDeclaration->pQualifierType->Accept( this );
00753    pQualifierDeclaration->pScope->Accept( this );
00754    if ( pQualifierDeclaration->pDefaultFlavor.get() != 0 )
00755    {
00756       pQualifierDeclaration->pDefaultFlavor->Accept( this );
00757    }
00758    CIMOMprocessQualifierType(pQualifierDeclaration->theLineInfo);
00759 }
00760 void CIMOMVisitor::VisitQualifierName( const QualifierName * )
00761 {
00762    assert(0);
00763 }
00764 void CIMOMVisitor::VisitQualifierType( const QualifierType *pQualifierType )
00765 {
00766    CIMDataType dt = CIMDataType::getDataType(*pQualifierType->pDataType->pDataType);
00767    if ( pQualifierType->pArray.get() != 0 )
00768    {
00769       Int64 arraySize = 0;
00770       if (pQualifierType->pArray->pArray.get() != 0)
00771       {
00772          pQualifierType->pArray->pArray->Accept( this );
00773          m_curValue.get(arraySize);
00774       }
00775       dt.setToArrayType(arraySize);
00776    }
00777    m_curQualifierType.setDataType(dt);
00778    if ( pQualifierType->pDefaultValue.get() != 0 )
00779    {
00780       pQualifierType->pDefaultValue->Accept( this );
00781       m_curQualifierType.setDefaultValue(m_curValue);
00782    }
00783 }
00784 void CIMOMVisitor::VisitScope( const Scope *pScope )
00785 {
00786    for ( List<MetaElement *>::const_iterator i = pScope->pMetaElement->begin();
00787        i != pScope->pMetaElement->end();
00788        ++i )
00789    {
00790       CIMScope scope;
00791       /* Removed by CIM Specification 2.2 Addenda Sheet: 01
00792       http://www.dmtf.org/spec/release/CIM_Errata/CIM_Spec_Addenda221.htm
00793       Our grammar still parses this, because it's used in CIM_Schema23.mof,
00794       So the user will just get a warning.
00795       if ((*i)->pMetaElement->equalsIgnoreCase("SCHEMA"))
00796       {
00797          scope = CIMScope(CIMScope::SCHEMA);
00798       }
00799       else*/
00800       if ((*i)->pMetaElement->equalsIgnoreCase("CLASS"))
00801       {
00802          scope = CIMScope(CIMScope::CLASS);
00803       }
00804       else if ((*i)->pMetaElement->equalsIgnoreCase("ASSOCIATION"))
00805       {
00806          scope = CIMScope(CIMScope::ASSOCIATION);
00807       }
00808       else if ((*i)->pMetaElement->equalsIgnoreCase("INDICATION"))
00809       {
00810          scope = CIMScope(CIMScope::INDICATION);
00811       }
00812       else if ((*i)->pMetaElement->equalsIgnoreCase("QUALIFIER"))
00813       {
00814          scope = CIMScope(CIMScope::QUALIFIER);
00815       }
00816       else if ((*i)->pMetaElement->equalsIgnoreCase("PROPERTY"))
00817       {
00818          scope = CIMScope(CIMScope::PROPERTY);
00819       }
00820       else if ((*i)->pMetaElement->equalsIgnoreCase("REFERENCE"))
00821       {
00822          scope = CIMScope(CIMScope::REFERENCE);
00823       }
00824       else if ((*i)->pMetaElement->equalsIgnoreCase("METHOD"))
00825       {
00826          scope = CIMScope(CIMScope::METHOD);
00827       }
00828       else if ((*i)->pMetaElement->equalsIgnoreCase("PARAMETER"))
00829       {
00830          scope = CIMScope(CIMScope::PARAMETER);
00831       }
00832       else if ((*i)->pMetaElement->equalsIgnoreCase("ANY"))
00833       {
00834          scope = CIMScope(CIMScope::ANY);
00835       }
00836       else
00837       {
00838          theErrorHandler->recoverableError(
00839             Format("Invalid scope: %1", *(*i)->pMetaElement).c_str(),
00840             (*i)->theLineInfo );
00841       }
00842       
00843       m_curQualifierType.addScope(scope);
00844    }
00845 }
00846 void CIMOMVisitor::VisitMetaElement( const MetaElement * )
00847 {
00848    assert(0);
00849 }
00850 void CIMOMVisitor::VisitDefaultFlavor( const DefaultFlavor *pDefaultFlavor )
00851 {
00852    for ( List<Flavor *>::const_iterator i = pDefaultFlavor->pFlavor->begin();
00853        i != pDefaultFlavor->pFlavor->end();
00854        ++i )
00855    {
00856       if ((*i)->pFlavor->equalsIgnoreCase("ENABLEOVERRIDE"))
00857       {
00858          m_curQualifierType.addFlavor(CIMFlavor(CIMFlavor::ENABLEOVERRIDE));
00859       }
00860       else if ((*i)->pFlavor->equalsIgnoreCase("DISABLEOVERRIDE"))
00861       {
00862          m_curQualifierType.addFlavor(CIMFlavor(CIMFlavor::DISABLEOVERRIDE));
00863       }
00864       else if ((*i)->pFlavor->equalsIgnoreCase("RESTRICTED"))
00865       {
00866          m_curQualifierType.addFlavor(CIMFlavor(CIMFlavor::RESTRICTED));
00867       }
00868       else if ((*i)->pFlavor->equalsIgnoreCase("TOSUBCLASS"))
00869       {
00870          m_curQualifierType.addFlavor(CIMFlavor(CIMFlavor::TOSUBCLASS));
00871       }
00872       else if ((*i)->pFlavor->equalsIgnoreCase("TRANSLATABLE"))
00873       {
00874          m_curQualifierType.addFlavor(CIMFlavor(CIMFlavor::TRANSLATE));
00875       }
00876       else
00877       {
00878          theErrorHandler->fatalError(
00879             Format("Internal Compiler Error. Invalid flavor: %1", *(*i)->pFlavor).c_str(),
00880             (*i)->theLineInfo);
00881       }
00882    }
00883 }
00884 void CIMOMVisitor::VisitInstanceDeclaration( const InstanceDeclaration *pInstanceDeclaration )
00885 {
00886    CIMClass cc = getClass(*pInstanceDeclaration->pClassName->pClassName, pInstanceDeclaration->theLineInfo);
00887       //m_hdl->getClass(m_namespace,
00888       //*pInstanceDeclaration->pClassName->pClassName, false);
00889    m_curInstance = cc.newInstance();
00890    if ( pInstanceDeclaration->pQualifier.get() != 0 )
00891    {
00892       for ( List<Qualifier *>::const_iterator i = pInstanceDeclaration->pQualifier->begin();
00893            i != pInstanceDeclaration->pQualifier->end(); ++i )
00894       {
00895          (*i)->Accept( this );
00896          if (!m_opts.m_removeDescriptions || !m_curQualifier.getName().equalsIgnoreCase(CIMQualifier::CIM_QUAL_DESCRIPTION))
00897          {
00898             m_curInstance.setQualifier(m_curQualifier);
00899          }
00900       }
00901    }
00902    if ( pInstanceDeclaration->pValueInitializer.get() != 0 )
00903    {
00904       for ( List<ValueInitializer *>::const_iterator i = pInstanceDeclaration->pValueInitializer->begin();
00905            i != pInstanceDeclaration->pValueInitializer->end(); ++i )
00906       {
00907          (*i)->Accept( this );
00908          CIMProperty tempProp = m_curInstance.getProperty(m_curProperty.getName());
00909          if (tempProp)
00910          {
00911             CIMQualifierArray newQuals = m_curProperty.getQualifiers();
00912             for (size_t i = 0; i < newQuals.size(); ++i)
00913             {
00914                tempProp.setQualifier(newQuals[i]);
00915             }
00916             if (m_curProperty.getValue())
00917             {
00918                CIMValue castValue(CIMNULL);
00919                try
00920                {
00921                   castValue = CIMValueCast::castValueToDataType(
00922                      m_curProperty.getValue(),
00923                      CIMDataType(tempProp.getDataType()));
00924 
00925                   CIMInstanceArray instances;
00926                   CIMClassArray classes;
00927                   CIMQualifierTypeArray qualifiertypes;
00928 
00929                   if( tempProp.getQualifier(CIMQualifier::CIM_QUAL_EMBEDDEDOBJECT) )
00930                   {
00931                      CIMDataType type = tempProp.getDataType();
00932                      if( type.getType() != CIMDataType::STRING )
00933                      {
00934                         castValue = CIMValue(CIMNULL);
00935                         theErrorHandler->recoverableError(
00936                            Format("Value is not the correct type: %1  The type for an EmbeddedObject should be: %2", m_curProperty.getValue().toString(), 
00937                               CIMDataType(CIMDataType::STRING).toString()).c_str(), pInstanceDeclaration->theLineInfo);
00938                      }
00939                      else
00940                      {
00941                         try
00942                         {
00943                            // Ok the base type is correct (string) and we're converting to an
00944                            // embedded object
00945                            if( type.isArrayType() )
00946                            {
00947                               StringArray arr = castValue.toStringArray();
00948                               for( StringArray::iterator j = arr.begin(); j != arr.end(); ++j )
00949                               {
00950                                  compileMOF(*j, m_hdl, m_namespace, instances, classes, qualifiertypes);
00951                               }
00952                            }
00953                            else
00954                            compileMOF(castValue.toString(), m_hdl, m_namespace, instances, classes, qualifiertypes);
00955                         }
00956                         catch(MOFCompilerException & e)
00957                         {
00958                            // We've got some kind of parsing error
00959                            castValue = CIMValue(CIMNULL);
00960                            theErrorHandler->recoverableError(
00961                               Format(
00962                                  "Instantiation error: %1.  "
00963                                  "An error occurred converting to an EmbeddedObject: %2",
00964                                  m_curProperty.getValue().toString(),
00965                                  e
00966                               ).c_str(),
00967                               pInstanceDeclaration->theLineInfo
00968                            );
00969                         }
00970                      }
00971                      
00972                      bool bHaveInstances = instances.size() > 0;
00973                      bool bHaveClasses = classes.size() > 0;
00974                      
00975                      if( bHaveInstances && bHaveClasses )
00976                      {
00977                         castValue = CIMValue(CIMNULL);
00978                         theErrorHandler->recoverableError(
00979                            Format(
00980                               "Instantiation error: %1.  "
00981                               "There were mixed EmbeddedObject types",
00982                               m_curProperty.getValue().toString()
00983                            ).c_str(),
00984                            pInstanceDeclaration->theLineInfo
00985                         );
00986                      }
00987                      else if ( type.isArrayType() )
00988                      {
00989                         castValue = bHaveClasses ? CIMValue(classes) : CIMValue(instances);
00990                      }
00991                      else if( bHaveInstances )
00992                      {
00993                         castValue = CIMValue(instances[0]);
00994                         if (instances.size() > 1)
00995                         {
00996                            theErrorHandler->recoverableError(
00997                               "Instantiation error: multiple instances specified for embedded object",
00998                               pInstanceDeclaration->theLineInfo
00999                            );
01000                         }
01001                      }
01002                      else if( bHaveClasses )
01003                      {
01004                         castValue = CIMValue(classes[0]);
01005                         if (classes.size() > 1)
01006                         {
01007                            theErrorHandler->recoverableError(
01008                               "Instantiation error: multiple class defs given for embedded object",
01009                               pInstanceDeclaration->theLineInfo
01010                            );
01011                         }
01012                      }
01013                      else
01014                      {
01015                         castValue = CIMValue(CIMNULL);
01016                         theErrorHandler->recoverableError(
01017                            "Instantiation error: no instance or classes specified for embedded object",
01018                            pInstanceDeclaration->theLineInfo
01019                         );
01020                      }
01021                   }
01022                }
01023                catch (ValueCastException&)
01024                {
01025                   theErrorHandler->recoverableError(
01026                         Format("Value is not the correct type: %1.  The type should be: %2", m_curProperty.getValue().toString(), tempProp.getDataType().toString()).c_str(), pInstanceDeclaration->theLineInfo);
01027                }
01028                if (castValue && castValue.getType() == CIMDataType::REFERENCE)
01029                {
01030                   CIMObjectPath cop(CIMNULL);
01031                   castValue.get(cop);
01032                   if (cop)
01033                   {
01034                      // If the object path doesn't have a : character, then we need to set the namespace on it.
01035                      if (m_curProperty.getValue().toString().indexOf(':') == String::npos)
01036                      {
01037                         cop.setNameSpace(m_namespace);
01038                         castValue = CIMValue(cop);
01039                      }
01040                   }
01041                }
01042                tempProp.setValue(castValue);
01043             }
01044             m_curInstance.setProperty(tempProp);
01045          }
01046          else
01047          {
01048             m_curInstance.setProperty(m_curProperty);
01049          }
01050       }
01051    }
01052    
01053    if ( pInstanceDeclaration->pAlias.get() != 0 )
01054    {
01055       CIMObjectPath cop(m_namespace, m_curInstance);
01056       
01057       m_aliasMap[*(pInstanceDeclaration->pAlias->pAliasIdentifier->pAliasIdentifier)] =
01058          m_namespace + ":" + cop.modelPath();
01059    }
01060    CIMOMprocessInstance(pInstanceDeclaration->theLineInfo);
01061 }
01062 void CIMOMVisitor::VisitValueInitializer( const ValueInitializer *pValueInitializer )
01063 {
01064    m_curProperty = CIMProperty(*pValueInitializer->pValueInitializer);
01065    if ( pValueInitializer->pQualifier.get() != 0 )
01066    {
01067       for ( List<Qualifier *>::const_iterator i = pValueInitializer->pQualifier->begin();
01068            i != pValueInitializer->pQualifier->end(); ++i )
01069       {
01070          (*i)->Accept( this );
01071          if (!m_opts.m_removeDescriptions || !m_curQualifier.getName().equalsIgnoreCase(CIMQualifier::CIM_QUAL_DESCRIPTION))
01072          {
01073             m_curProperty.setQualifier(m_curQualifier);
01074          }
01075       }
01076    }
01077    pValueInitializer->pDefaultValue->Accept( this );
01078    m_curProperty.setValue(m_curValue);
01079 }
01080 void CIMOMVisitor::VisitIntegerValueBinaryValue( const IntegerValueBinaryValue *pIntegerValueBinaryValue )
01081 {
01082    Int64 val = pIntegerValueBinaryValue->pBinaryValue->toInt64(2);
01083    m_curValue = CIMValue(val);
01084 }
01085 void CIMOMVisitor::VisitIntegerValueOctalValue( const IntegerValueOctalValue *pIntegerValueOctalValue )
01086 {
01087    Int64 val = pIntegerValueOctalValue->pOctalValue->toInt64(8);
01088    m_curValue = CIMValue(val);
01089 }
01090 void CIMOMVisitor::VisitIntegerValueDecimalValue( const IntegerValueDecimalValue *pIntegerValueDecimalValue )
01091 {
01092    Int64 val = pIntegerValueDecimalValue->pDecimalValue->toInt64(10);
01093    m_curValue = CIMValue(val);
01094 }
01095 void CIMOMVisitor::VisitIntegerValueHexValue( const IntegerValueHexValue *pIntegerValueHexValue )
01096 {
01097    Int64 val = pIntegerValueHexValue->pHexValue->toInt64(16);
01098    m_curValue = CIMValue(val);
01099 }
01100 void CIMOMVisitor::VisitConstantValueIntegerValue( const ConstantValueIntegerValue *pConstantValueIntegerValue )
01101 {
01102    pConstantValueIntegerValue->pIntegerValue->Accept( this );
01103 }
01104 void CIMOMVisitor::VisitConstantValueFloatValue( const ConstantValueFloatValue *pConstantValueFloatValue )
01105 {
01106    Real64 val = pConstantValueFloatValue->pFloatValue->toReal64();
01107    m_curValue = CIMValue(val);
01108 }
01109 void CIMOMVisitor::VisitConstantValueStringValue( const ConstantValueStringValue *pConstantValueStringValue )
01110 {
01111    m_curValue = CIMValue(Compiler::fixParsedString(*pConstantValueStringValue->pStringValue));
01112 }
01113 void CIMOMVisitor::VisitConstantValueCharValue( const ConstantValueCharValue *pConstantValueCharValue )
01114 {
01115    char c = pConstantValueCharValue->pCharValue->charAt(1);
01116    m_curValue = CIMValue(c);
01117 }
01118 void CIMOMVisitor::VisitConstantValueBooleanValue( const ConstantValueBooleanValue *pConstantValueBooleanValue )
01119 {
01120    Bool b;
01121    if (pConstantValueBooleanValue->pBooleanValue->equalsIgnoreCase("TRUE"))
01122    {
01123       b = true;
01124    }
01125    else
01126    {
01127       b = false;
01128    }
01129    m_curValue = CIMValue(b);
01130 }
01131 void CIMOMVisitor::VisitConstantValueNullValue( const ConstantValueNullValue * )
01132 {
01133    m_curValue.setNull();
01134 }
01135 CIMDataType CIMOMVisitor::getQualifierDataType(const String& qualName, const LineInfo& li)
01136 {
01137    return getQualifierType(qualName, li).getDataType();
01138 }
01139 CIMQualifierType CIMOMVisitor::getQualifierType(const String& qualName, const LineInfo& li)
01140 {
01141    String lcqualName = qualName;
01142    lcqualName.toLowerCase();
01143    // TODO: Fix this to include the namespace in the key
01144    CIMQualifierType qt = m_dataTypeCache.getFromCache(lcqualName);
01145    if (!qt)
01146    {
01147       qt = CIMOMgetQualifierType(qualName, li);
01148       // TODO: Fix this to include the namespace in the key
01149       m_dataTypeCache.addToCache(qt, lcqualName);
01150    }
01151    return qt;
01152 }
01153 CIMClass CIMOMVisitor::getClass(const String& className, const LineInfo& li)
01154 {
01155    String lcclassName = className;
01156    lcclassName.toLowerCase();
01157    // TODO: Fix this to include the namespace in the key
01158    CIMClass c = m_classCache.getFromCache(lcclassName);
01159    if (!c)
01160    {
01161       c = CIMOMgetClass(className, li);
01162       // TODO: Fix this to include the namespace in the key
01163       m_classCache.addToCache(c, lcclassName);
01164    }
01165    return c;
01166 }
01167 
01168 void CIMOMVisitor::CIMOMprocessClassAux(const LineInfo& li)
01169 {
01170    if (m_opts.m_removeObjects)
01171    {
01172       // since we don't go to the effort of deleting the classes backwards, the first classes we come across in a typical mof may
01173       // be base classes. If a base class is deleted, all sub classes go with it, so subsequent delete classes may cause an
01174       // exception to be thrown, which we just want to ignore.
01175       try
01176       {
01177          m_hdl->deleteClass(m_namespace, m_curClass.getName());
01178       }
01179       catch (CIMException& e)
01180       {
01181          if (e.getErrNo() != CIMException::NOT_FOUND && e.getErrNo() != CIMException::INVALID_CLASS)
01182          {
01183             throw;
01184          }
01185       }
01186    }
01187    else
01188    {
01189       m_hdl->createClass(m_namespace, m_curClass);
01190    }
01191 }
01192 
01193 static 
01194 String findMOF(const String& path, const String& file)
01195 {
01196    StringArray contents; 
01197    String rval; 
01198    if (!FileSystem::getDirectoryContents(path, contents))
01199    {
01200       return rval; 
01201    }
01202    for (StringArray::const_iterator iter = contents.begin(); 
01203         iter != contents.end(); ++iter)
01204    {
01205       if (iter->equals("..") || iter->equals("."))
01206       {
01207          continue; 
01208       }
01209       String curFile = path + OW_FILENAME_SEPARATOR + *iter;
01210       if (FileSystem::isDirectory(curFile)) 
01211       {
01212          rval = findMOF(curFile,file); 
01213          if (!rval.empty())
01214          {
01215             return rval; 
01216          }
01217       }
01218       else if (iter->equalsIgnoreCase(file))
01219       {
01220          return curFile; 
01221       }
01222    }
01223    return rval; 
01224 }
01225 
01226 void CIMOMVisitor::compileDep(const String& className, const LineInfo& li)
01227 {
01228    String basename = className + ".mof"; 
01229    basename.toLowerCase(); 
01230    String filename = findMOF(m_opts.m_depSearchDir, 
01231                        basename); 
01232    if (filename.empty())
01233    {
01234       theErrorHandler->fatalError(Format("Unable to find file for class %1", className).c_str(), li); 
01235    }
01236    theErrorHandler->progressMessage(Format("Found file %1 for class %2",
01237                                  filename, className).c_str(), li);
01238    Compiler theCompiler(m_hdl, m_opts, theErrorHandler); 
01239    theCompiler.compile(filename); 
01240 }
01241 
01242 void CIMOMVisitor::compileQuals(const LineInfo& li)
01243 {
01244    String basename = "qualifiers.mof"; 
01245    String filename = findMOF(m_opts.m_depSearchDir, basename); 
01246    if (filename.empty())
01247    {
01248       theErrorHandler->fatalError(Format("Unable to find file ", basename).c_str(), li); 
01249    }
01250    theErrorHandler->progressMessage(Format("Found file %1 for Qualifiers",
01251                                  filename).c_str(), li);
01252    Compiler theCompiler(m_hdl, m_opts, theErrorHandler); 
01253    theCompiler.compile(filename); 
01254 }
01255 
01256 
01257 void CIMOMVisitor::CIMOMprocessClass(const LineInfo& li)
01258 {
01259    theErrorHandler->progressMessage(Format("Processing Class: %1", m_curClass.getName()).c_str(), li);
01260 
01261    try
01262    {
01263       bool fixedNS, fixedRefs, fixedSuper; 
01264       for(fixedNS = fixedRefs = fixedSuper = false; 
01265           !fixedNS || !fixedRefs || !fixedSuper ; )
01266       {
01267          try
01268          {
01269             CIMOMprocessClassAux(li);
01270             const char* const msg = m_opts.m_removeObjects ? "Deleted Class: %1" : "Created Class: %1";
01271             theErrorHandler->progressMessage(Format(msg, m_curClass.getName()).c_str(), li);
01272             break; 
01273             // Note we won't add the class to the cache, since mof usually 
01274             // is just creating classes, it'll be mostly a waste of time.  
01275             // getClass will put classes in the cache, in the case that 
01276             // there are lots of instances, each class will only have to 
01277             // be fetched once.
01278          }
01279          catch (CIMException& e)
01280          {
01281             switch (e.getErrNo())
01282             {
01283             case CIMException::INVALID_NAMESPACE:
01284             {
01285                if (fixedNS || !m_opts.m_createNamespaces)
01286                {
01287                   throw; 
01288                }
01289                CIMOMcreateNamespace(li);
01290                fixedNS = true; 
01291                break; 
01292             }
01293             case CIMException::INVALID_PARAMETER:
01294             {
01295                if (fixedRefs || m_opts.m_depSearchDir.empty())
01296                {
01297                   throw; 
01298                }
01299                CIMPropertyArray cpa = m_curClass.getAllProperties(); 
01300                for (CIMPropertyArray::const_iterator iter = cpa.begin(); 
01301                     iter != cpa.end(); ++iter)
01302                {
01303                   const CIMProperty& prop = *iter; 
01304                   if (prop.isReference())
01305                   {
01306                      CIMDataType cdt = prop.getDataType(); 
01307                      String classToFind = cdt.getRefClassName(); 
01308                      StringArray emptyProps; 
01309                      try
01310                      {
01311                         m_hdl->getClass(m_namespace, classToFind, 
01312                                     E_LOCAL_ONLY, 
01313                                     E_EXCLUDE_QUALIFIERS, 
01314                                     E_EXCLUDE_CLASS_ORIGIN, 
01315                                     &emptyProps); 
01316                      }
01317                      catch (CIMException& ce)
01318                      {
01319                         theErrorHandler->progressMessage(
01320                            Format("Class %1 referenced by reference property %2 doesn't exist in namespace %3, searching...", 
01321                                  classToFind, prop.getName(), m_namespace).c_str(), li);
01322                         if (ce.getErrNo() == CIMException::NOT_FOUND)
01323                         {
01324                            compileDep(classToFind, li); 
01325                         }
01326                      }
01327                   }
01328                }
01329                fixedRefs = true; 
01330                break; 
01331             }
01332             case CIMException::INVALID_SUPERCLASS:
01333             {
01334                if (fixedSuper || m_opts.m_depSearchDir.empty())
01335                {
01336                   throw; 
01337                }
01338                String classToFind = m_curClass.getSuperClass(); 
01339                theErrorHandler->progressMessage(Format("Superclass %1 does not exist in namespace %2, searching...", 
01340                                           classToFind, m_namespace).c_str(), li);
01341                compileDep(classToFind, li); 
01342                fixedSuper = true; 
01343                break; 
01344             }
01345             default: 
01346                throw; 
01347             }
01348          }
01349       }
01350    }
01351    catch (CIMException& e)
01352    {
01353       if (e.getErrNo() == CIMException::ALREADY_EXISTS)
01354       {
01355          try
01356          {
01357             m_hdl->modifyClass(m_namespace, m_curClass);
01358             theErrorHandler->progressMessage(Format("Updated Class: %1", m_curClass.getName()).c_str(), li);
01359          }
01360          catch (const CIMException& ce)
01361          {
01362             theErrorHandler->recoverableError(Format("Error: %1", ce.getMessage()).c_str(), li);
01363          }
01364       }
01365       else
01366       {
01367          theErrorHandler->fatalError(Format("Error: %1", e.getMessage()).c_str(), li);
01368       }
01369    }
01370 }
01371 
01372 void CIMOMVisitor::CIMOMprocessQualifierTypeAux()
01373 {
01374    // we don't delete qualifers.  Easier and safer to just leave them be. 
01375    if (!m_opts.m_removeObjects)
01376    {
01377       m_hdl->setQualifierType(m_namespace, m_curQualifierType);
01378    }
01379 }
01380 void CIMOMVisitor::CIMOMprocessQualifierType(const LineInfo& li)
01381 {
01382    try
01383    {
01384       theErrorHandler->progressMessage(Format("Processing Qualifier Type: %1", m_curQualifierType.getName()).c_str(), li);
01385       try
01386       {
01387          CIMOMprocessQualifierTypeAux();
01388       }
01389       catch (CIMException& e)
01390       {
01391          if (e.getErrNo() == CIMException::INVALID_NAMESPACE && m_opts.m_createNamespaces)
01392          {
01393             CIMOMcreateNamespace(li);
01394             CIMOMprocessQualifierTypeAux();
01395          }
01396          else
01397          {
01398             throw;
01399          }
01400       }
01401       // save it in the cache
01402       String lcqualName = m_curQualifierType.getName();
01403       lcqualName.toLowerCase();
01404       // TODO: Fix this to include the namespace in the key
01405       m_dataTypeCache.addToCache(m_curQualifierType, lcqualName);
01406 
01407       const char* const msg = m_opts.m_removeObjects ? "Not Deleting Qualifier Type: %1" : "Created Qualifier Type: %1";
01408       theErrorHandler->progressMessage(Format(msg, m_curQualifierType.getName()).c_str(), li);
01409    }
01410    catch (const CIMException& ce)
01411    {
01412       theErrorHandler->fatalError(Format("Error: %1", ce.getMessage()).c_str(), li);
01413    }
01414 }
01415 
01416 void CIMOMVisitor::CIMOMprocessInstanceAux()
01417 {
01418    if (m_opts.m_removeObjects)
01419    {
01420       // since we don't go to the effort of deleting the classes & instances backwards, the first classes we come across in a typical mof may
01421       // be base classes. If a base class is deleted, all sub classes and instances go with it, so subsequent deleteInstance()s may cause an
01422       // exception to be thrown, which we just want to ignore.
01423       try
01424       {
01425          m_hdl->deleteInstance(m_namespace, CIMObjectPath(m_namespace, m_curInstance));
01426       }
01427       catch (CIMException& e)
01428       {
01429          if (e.getErrNo() != CIMException::NOT_FOUND && e.getErrNo() != CIMException::INVALID_CLASS)
01430          {
01431             throw;
01432          }
01433       }
01434    }
01435    else
01436    {
01437       m_hdl->createInstance(m_namespace, m_curInstance);
01438    }
01439 }
01440 
01441 void CIMOMVisitor::CIMOMprocessInstance(const LineInfo& li)
01442 {
01443    CIMObjectPath cop(m_namespace, m_curInstance);
01444    theErrorHandler->progressMessage(Format("Processing Instance: %1", cop.toString()).c_str(), li);
01445    try
01446    {
01447       try
01448       {
01449          CIMOMprocessInstanceAux();
01450       }
01451       catch (CIMException& e)
01452       {
01453          if (e.getErrNo() == CIMException::INVALID_NAMESPACE && m_opts.m_createNamespaces)
01454          {
01455             CIMOMcreateNamespace(li);
01456             CIMOMprocessInstanceAux();
01457          }
01458          else
01459          {
01460             throw;
01461          }
01462       }
01463       const char* const msg = m_opts.m_removeObjects ? "Deleted Instance: %1" : "Created Instance: %1";
01464       theErrorHandler->progressMessage(Format(msg, cop.toString()).c_str(), li);
01465    }
01466    catch (const CIMException& ce)
01467    {
01468       if (ce.getErrNo() == CIMException::ALREADY_EXISTS)
01469       {
01470          try
01471          {
01472             m_hdl->modifyInstance(m_namespace, m_curInstance);
01473             theErrorHandler->progressMessage(Format("Updated Instance: %1", cop.toString()).c_str(), li);
01474          }
01475          catch (const CIMException& ce)
01476          {
01477             theErrorHandler->fatalError(Format("Error: %1", ce.getMessage()).c_str(), li);
01478          }
01479       }
01480       else
01481       {
01482          theErrorHandler->fatalError(Format("Error: %1", ce.getMessage()).c_str(), li);
01483       }
01484    }
01485 }
01486 CIMQualifierType CIMOMVisitor::CIMOMgetQualifierType(const String& qualName, const LineInfo& li)
01487 {
01488    try
01489    {
01490       try
01491       {
01492          return m_hdl->getQualifierType(m_namespace, qualName);
01493       }
01494       catch (CIMException& e)
01495       {
01496          if (e.getErrNo() == CIMException::INVALID_NAMESPACE && m_opts.m_createNamespaces)
01497          {
01498             CIMOMcreateNamespace(li);
01499             if (!m_opts.m_depSearchDir.empty())
01500             {
01501                compileQuals(li); 
01502             }
01503             return m_hdl->getQualifierType(m_namespace, qualName);
01504          }
01505          else if (e.getErrNo() == CIMException::NOT_FOUND 
01506                   && !m_opts.m_depSearchDir.empty())
01507          {
01508             compileQuals(li); 
01509             return m_hdl->getQualifierType(m_namespace, qualName);
01510          }
01511          else
01512          {
01513             throw;
01514          }
01515       }
01516    }
01517    catch (const CIMException& ce)
01518    {
01519       theErrorHandler->fatalError(Format("Error: %1", ce.getMessage()).c_str(), li);
01520    }
01521    return CIMQualifierType();
01522 }
01523 CIMClass CIMOMVisitor::CIMOMgetClass(const String& className, const LineInfo& li)
01524 {
01525    try
01526    {
01527       try
01528       {
01529          return m_hdl->getClass(m_namespace, className, E_NOT_LOCAL_ONLY);
01530       }
01531       catch (CIMException& e)
01532       {
01533          if (e.getErrNo() == CIMException::INVALID_NAMESPACE && m_opts.m_createNamespaces)
01534          {
01535             CIMOMcreateNamespace(li);
01536             return m_hdl->getClass(m_namespace, className, E_NOT_LOCAL_ONLY);
01537          }
01538          else
01539          {
01540             // if we're removing things, the class is already gone, so just hand back a dummy
01541             if (e.getErrNo() == CIMException::NOT_FOUND && m_opts.m_removeObjects)
01542             {
01543                return CIMClass(className);
01544             }
01545             else
01546             {
01547                throw;
01548             }
01549          }
01550       }
01551    }
01552    catch (const CIMException& ce)
01553    {
01554       theErrorHandler->fatalError(Format("Error: %1", ce.getMessage()).c_str(), li);
01555    }
01556    return CIMClass();
01557 }
01558 
01559 void CIMOMVisitor::CIMOMcreateNamespace(const LineInfo& li)
01560 {
01561    // don't bother catching exceptions here.  This function is only called if
01562    // the namespace needs to exist.  If we can't create the namespace, that's
01563    // a fatal error.
01564    theErrorHandler->progressMessage(Format("Creating Namespace: %1", m_namespace).c_str(), li);
01565    if (m_rephdl)
01566    {
01567       m_rephdl->createNameSpace(m_namespace);
01568    }
01569    else
01570    {
01571       try
01572       {
01573          CIMNameSpaceUtils::createCIM_Namespace(*m_hdl, m_namespace);
01574       }
01575       catch (const CIMException& e)
01576       {
01577          // server doesn't support CIM_Namespace, try __Namespace
01578          CIMNameSpaceUtils::create__Namespace(*m_hdl, m_namespace);
01579       }
01580 
01581    }
01582    theErrorHandler->progressMessage(Format("Created Namespace: %1", m_namespace).c_str(), li);
01583 }
01584 
01585 } // end namespace MOF
01586 } // end namespace OW_NAMESPACE
01587 

Generated on Thu Feb 9 08:48:07 2006 for openwbem by  doxygen 1.4.6