int FinalizeInstance()

in LCM/codec/mof/parser/types.c [3628:3824]

• 179 lines of code
• 30 McCabe index (conditional complexity)

int FinalizeInstance(
    void * mofstate,
    MI_InstanceDecl* id)
{
    const MI_ClassDecl* cd;
    MI_Uint32 i;
    MI_Uint32 j;
    MOF_State * state = (MOF_State *)mofstate;
    MI_Boolean validClassDecl = MI_TRUE;
    MI_Instance *inst = NULL;
    MI_Result r = MI_RESULT_OK;
    MI_Boolean isClassDeclFromBuffer = MI_FALSE;
    /* Find the class declaration for this instance */
    {
        cd = FindClassDecl(state, id->name);
        if (!cd)
        {
            /* Process according to schema check option */
            switch(state->parser->param.schemacheck)
            {
            case SCHEMA_CHECK_DEFAULT:
            case SCHEMA_CHECK_IGNORE_PROPERTYTYPE:
            case SCHEMA_CHECK_STRICT:
            case SCHEMA_CHECK_LOOSE:
                {
                    yyerrorf(state->errhandler, ID_UNDEFINED_CLASS, "", id->name);
                    return -1;
                }
                break;
            case SCHEMA_CHECK_IGNORE:
                {
                    yywarnf(state->errhandler, ID_UNDEFINED_CLASS, "", id->name);
                    validClassDecl = MI_FALSE;
                }
                break;
            }
        }
        isClassDeclFromBuffer = state->internalstate.isClassDeclFromBuffer;
        id->decl = cd;
    }

    if (cd)
    {
        /* For each instance property */
        for (i = 0; i < id->numProperties; i++)
        {
            MI_PropertyDecl* p = id->properties[i];
            MI_PropertyDecl* q = NULL;

            /* Find the class property with the same name */
            {
                for (j = 0; j < cd->numProperties; j++)
                {
                    if (Tcscasecmp(cd->properties[j]->name, p->name) == 0)
                    {
                        q = cd->properties[j];
                        break;
                    }
                }

                if (!q)
                {
                    /* Process according to schema check option */
                    switch(state->parser->param.schemacheck)
                    {
                    case SCHEMA_CHECK_DEFAULT:
                    case SCHEMA_CHECK_IGNORE_PROPERTYTYPE:
                    case SCHEMA_CHECK_STRICT:
                        {
                            yyerrorf(state->errhandler, ID_UNDEFINED_PROPERTY, "", p->name);
                            return -1;
                        }
                        break;
                    case SCHEMA_CHECK_LOOSE:
                    case SCHEMA_CHECK_IGNORE:
                        {
                            yywarnf(state->errhandler, ID_UNDEFINED_PROPERTY, "", p->name);
                            validClassDecl = MI_FALSE;
                        }
                        break;
                    }
                }
            }

            if (q)
            {
                /* Promote instance property (to the type given by class property) */
                MI_Boolean embeddedpropertyError;
                if (_PromoteValue(state, p->type, q, &embeddedpropertyError, &p->value) != 0)
                {
                    // check return value from _PromoteValue
                    if (state->parser->param.schemacheck & SCHEMA_CHECK_IGNORE_PROPERTYTYPE)
                    {
                        yywarnf(state->errhandler, ID_CONVERT_PROPERTY_VALUE_FAILED,
                            "",
                            p->name,
                            _getTypeName_MI((MI_Type)p->type),
                            _getTypeName_MI((MI_Type)q->type));
                        validClassDecl = MI_FALSE;
                    }
                    else
                    {
                        if (MI_TRUE != embeddedpropertyError)
                        {
                            yyerrorf(state->errhandler, ID_CONVERT_PROPERTY_VALUE_FAILED,
                                "",
                                p->name,
                                _getTypeName_MI((MI_Type)p->type),
                                _getTypeName_MI((MI_Type)q->type));
                        }
                        return -1;
                    }
                }
                else
                {
                    /* Assume type of class property if success */
                    p->type = q->type;
                }
            }
        }
    }

    /* create instance base on instance decl */
    if (validClassDecl)
    {
        const MI_ClassDecl *newDecl = id->decl;
        if(isClassDeclFromBuffer)
        {
            r = state->onNewClassDecl(state->onNewClassDeclData,
                id->decl, (MI_ClassDecl**)&newDecl);
        }
        if (r == MI_RESULT_OK)
        {
            if (newDecl != id->decl) id->decl = newDecl;
            r = state->Instance_New(newDecl, &inst);
#ifdef TEST_BUILD
            TASSERT(r == MI_RESULT_OK, L"Ignore out of memory error in unit test fault injection.");
#endif
        }
    }
    else
    {
        r = state->Instance_InitDynamic(id->name, MI_FLAG_CLASS, &inst);
#ifdef TEST_BUILD
        TASSERT(r == MI_RESULT_OK, L"Ignore out of memory error in unit test fault injection.");
#endif
    }

    if (r != MI_RESULT_OK)
    {
        yyerrorf(state->errhandler, ID_MI_CREATEINSTANCE_FAILED,
            "",
            tcs(id->name),
            r);
        return -1;
    }

    /* For each instance property */
    for (i = 0; i < id->numProperties; i++)
    {
        MI_PropertyDecl* p = id->properties[i];
        MI_Value *value = (MI_Value*)(p->value);
        if (validClassDecl)
        {
            r = MI_Instance_SetElement(inst, p->name, value, (MI_Type)p->type, 0);
#ifdef TEST_BUILD
            TASSERT(r == MI_RESULT_OK, L"Ignore out of memory error in unit test fault injection.");
#endif
            if (r != MI_RESULT_OK)
            {
                yyerrorf(state->errhandler, ID_MI_SET_PROPERTY_FAILED,
                    "",
                    tcs(p->name),
                    r);
                return -1;
            }
        }
        else
        {
            r = MI_Instance_AddElement(inst, p->name, value, (MI_Type)p->type, 0);
#ifdef TEST_BUILD
            TASSERT(r == MI_RESULT_OK, L"Ignore out of memory error in unit test fault injection.");
#endif
            if (r != MI_RESULT_OK)
            {
                yyerrorf(state->errhandler, ID_MI_ADD_PROPERTY_FAILED,
                    "",
                    tcs(p->name),
                    r);
                return -1;
            }
        }
    }
    /* create instance successfully */
    id->instance = inst;
    return 0;
}