in LCM/codec/mof/parser/types.c [623:1071]
static int _PromoteValue(
void * mofstate,
MI_Uint32 sourceType,
MI_PropertyDecl *destpropertydecl,
MI_Boolean * embeddedpropertyError,
void** value)
{
MI_Uint32 i;
MOF_State * state = (MOF_State *)mofstate;
MI_Uint32 destType = destpropertydecl->type;
*embeddedpropertyError = MI_FALSE;
/* Nothing to do if value is null */
if (*value == NULL)
return 0;
/* Convert from sourceType to destType */
switch (sourceType)
{
case MI_BOOLEAN:
{
if (destType != sourceType)
{
return -1;
}
return 0;
}
case MI_SINT64:
{
const MI_Sint64* p = *((const MI_Sint64**)value);
switch (destType)
{
case MI_UINT8:
{
MI_Uint8* q = MALLOC_T(MI_Uint8, 1);
MI_Sint64 x = *p;
if (_CheckRange(state, x, MI_UINT8) != 0)
return -1;
*q = (MI_Uint8)x;
*value = q;
return 0;
}
case MI_SINT8:
{
MI_Sint8* q = MALLOC_T(MI_Sint8, 1);
MI_Sint64 x = *p;
if (_CheckRange(state, x, MI_SINT8) != 0)
return -1;
*q = (MI_Sint8)x;
*value = q;
return 0;
}
case MI_UINT16:
{
MI_Uint16* q = MALLOC_T(MI_Uint16, 1);
MI_Sint64 x = *p;
if (_CheckRange(state, x, MI_UINT16) != 0)
return -1;
*q = (MI_Uint16)x;
*value = q;
return 0;
}
case MI_SINT16:
{
MI_Sint16* q = MALLOC_T(MI_Sint16, 1);
MI_Sint64 x = *p;
if (_CheckRange(state, x, MI_SINT16) != 0)
return -1;
*q = (MI_Sint16)x;
*value = q;
return 0;
}
case MI_UINT32:
{
MI_Uint32* q = MALLOC_T(MI_Uint32, 1);
MI_Sint64 x = *p;
if (_CheckRange(state, x, MI_UINT32) != 0)
return -1;
*q = (MI_Uint32)x;
*value = q;
return 0;
}
case MI_SINT32:
{
MI_Sint32* q = MALLOC_T(MI_Sint32, 1);
MI_Sint64 x = *p;
if (_CheckRange(state, x, MI_SINT32) != 0)
return -1;
*q = (MI_Sint32)x;
*value = q;
return 0;
}
case MI_UINT64:
{
MI_Uint64* q = MALLOC_T(MI_Uint64, 1);
MI_Sint64 x = *p;
if (_CheckRange(state, x, MI_UINT64) != 0)
return -1;
*q = (MI_Uint64)x;
*value = q;
return 0;
}
case MI_SINT64:
{
return 0;
}
default:
{
return -1;
}
}
}
case MI_REAL64:
{
const MI_Real64* p = *((const MI_Real64**)value);
switch (destType)
{
case MI_REAL32:
{
MI_Real32* q = MALLOC_T(MI_Real32, 1);
*q = (MI_Real32)*p;
*value = q;
return 0;
}
case MI_REAL64:
{
return 0;
}
default:
{
return -1;
}
}
}
case MI_CHAR16:
{
if (destType != sourceType)
return -1;
return 0;
}
case MI_STRING:
{
switch (destType)
{
case MI_STRING:
{
return 0;
}
case MI_DATETIME:
{
void * pstringvalue = *value;
const MI_Char* p = *((const MI_Char**)pstringvalue);
MI_Datetime* q = MALLOC_T(MI_Datetime, 1);
if (_StrToDatetime(mofstate, p, q) != 0)
return -1;
*value = q;
return 0;
}
default:
{
return -1;
}
}
}
case MI_BOOLEANA:
{
if (destType != sourceType)
return -1;
return 0;
}
case MI_SINT64A:
{
const MI_Sint64A* p = *((const MI_Sint64A**)value);
switch (destType)
{
case MI_UINT8A:
{
MI_Uint8A* q;
NEW_ARRAY_T(q, MI_Uint8, p->size);
for (i = 0; i < p->size; i++)
{
MI_Sint64 x = p->data[i];
if (_CheckRange(state, x, MI_UINT8) != 0)
return -1;
q->data[i] = (MI_Uint8)x;
}
*value = q;
return 0;
}
case MI_SINT8A:
{
MI_Sint8A* q;
NEW_ARRAY_T(q, MI_Sint8, p->size);
for (i = 0; i < p->size; i++)
{
MI_Sint64 x = p->data[i];
if (_CheckRange(state, x, MI_SINT8) != 0)
return -1;
q->data[i] = (MI_Sint8)x;
}
*value = q;
return 0;
}
case MI_UINT16A:
{
MI_Uint16A* q;
NEW_ARRAY_T(q, MI_Uint16, p->size);
for (i = 0; i < p->size; i++)
{
MI_Sint64 x = p->data[i];
if (_CheckRange(state, x, MI_UINT16) != 0)
return -1;
q->data[i] = (MI_Uint16)x;
}
*value = q;
return 0;
}
case MI_SINT16A:
{
MI_Sint16A* q;
NEW_ARRAY_T(q, MI_Sint16, p->size);
for (i = 0; i < p->size; i++)
{
MI_Sint64 x = p->data[i];
if (_CheckRange(state, x, MI_SINT16) != 0)
return -1;
q->data[i] = (MI_Sint16)x;
}
*value = q;
return 0;
}
case MI_UINT32A:
{
MI_Uint32A* q;
NEW_ARRAY_T(q, MI_Uint32, p->size);
for (i = 0; i < p->size; i++)
{
MI_Sint64 x = p->data[i];
if (_CheckRange(state, x, MI_UINT32) != 0)
return -1;
q->data[i] = (MI_Uint32)x;
}
*value = q;
return 0;
}
case MI_SINT32A:
{
MI_Sint32A* q;
NEW_ARRAY_T(q, MI_Sint32, p->size);
for (i = 0; i < p->size; i++)
{
MI_Sint64 x = p->data[i];
if (_CheckRange(state, x, MI_SINT32) != 0)
return -1;
q->data[i] = (MI_Sint32)x;
}
*value = q;
return 0;
}
case MI_UINT64A:
{
MI_Uint64A* q;
NEW_ARRAY_T(q, MI_Uint64, p->size);
for (i = 0; i < p->size; i++)
{
MI_Sint64 x = p->data[i];
if (_CheckRange(state, x, MI_UINT64) != 0)
return -1;
q->data[i] = (MI_Uint64)x;
}
*value = q;
return 0;
}
case MI_SINT64A:
{
return 0;
}
default:
{
/* For empty array, just create another emptry array and return */
if (p->size == 0)
{
MI_Uint64A* q;
NEW_ARRAY_T(q, MI_Uint64, p->size);
q->data = NULL;
*value = q;
return 0;
}
return -1;
}
}
}
case MI_REAL64A:
{
const MI_Real64A* p = *((const MI_Real64A**)value);
switch (destType)
{
case MI_REAL64A:
{
return 0;
}
case MI_REAL32A:
{
MI_Real32A* q;
NEW_ARRAY_T(q, MI_Real32, p->size);
for (i = 0; i < p->size; i++)
{
q->data[i] = (MI_Real32)p->data[i];
}
*value = q;
return 0;
}
default:
return -1;
}
}
case MI_CHAR16A:
{
if (destType != sourceType)
return -1;
return 0;
}
case MI_STRINGA:
{
const MI_StringA* p = *((const MI_StringA**)value);
switch (destType)
{
case MI_STRINGA:
{
return 0;
}
case MI_DATETIMEA:
{
MI_DatetimeA* q;
NEW_ARRAY_T(q, MI_Datetime, p->size);
for (i = 0; i < p->size; i++)
{
if (_StrToDatetime(mofstate, p->data[i], &q->data[i]) != 0)
return -1;
}
*value = q;
return 0;
}
default:
return -1;
}
}
case MI_INSTANCE:
case MI_REFERENCE:
switch (destType)
{
case MI_INSTANCE:
case MI_REFERENCE:
{
MI_Instance * inst = *(*(MI_Instance***)value);
if (destpropertydecl->className)
{
*embeddedpropertyError = MI_TRUE;
return _IsInstanceOfClass(state, inst, destpropertydecl->className);
}
return 0;
}
}
break;
case MI_INSTANCEA:
case MI_REFERENCEA:
switch (destType)
{
case MI_INSTANCEA:
case MI_REFERENCEA:
{
const MI_InstanceA * insta = *(const MI_InstanceA**)value;
MI_Char *destclassname = destpropertydecl->className;
if (destclassname)
{
*embeddedpropertyError = MI_TRUE;
for (i = 0; i < insta->size; i++)
{
if (_IsInstanceOfClass(state, insta->data[i], destclassname) != 0)
return -1;
}
}
return 0;
}
}
break;
default:
break;
}
return -1;
}