00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
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
00104
00105 if (pCompilerDirective->pPragmaName->pPragmaName->equalsIgnoreCase("include"))
00106 {
00107
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
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
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
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
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
00355
00356
00357
00358 if (qt.getDataType().isArrayType())
00359 {
00360
00361
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
00411 CIMDataType dt = getQualifierDataType(m_curQualifier.getName(), pQualifierParameterConstantValue->theLineInfo);
00412
00413 m_curValue = CIMValueCast::castValueToDataType(m_curValue, dt);
00414 }
00415 void CIMOMVisitor::VisitQualifierParameterArrayInitializer( const QualifierParameterArrayInitializer *pQualifierParameterArrayInitializer )
00416 {
00417 pQualifierParameterArrayInitializer->pArrayInitializer->Accept( this );
00418
00419 CIMDataType dt = getQualifierDataType(m_curQualifier.getName(), pQualifierParameterArrayInitializer->theLineInfo);
00420
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
00792
00793
00794
00795
00796
00797
00798
00799
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
00888
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
00944
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
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
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
01144 CIMQualifierType qt = m_dataTypeCache.getFromCache(lcqualName);
01145 if (!qt)
01146 {
01147 qt = CIMOMgetQualifierType(qualName, li);
01148
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
01158 CIMClass c = m_classCache.getFromCache(lcclassName);
01159 if (!c)
01160 {
01161 c = CIMOMgetClass(className, li);
01162
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
01173
01174
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
01274
01275
01276
01277
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
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
01402 String lcqualName = m_curQualifierType.getName();
01403 lcqualName.toLowerCase();
01404
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
01421
01422
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
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
01562
01563
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
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 }
01586 }
01587