BOOL CApp::InitCommon()
{
    try
    {
        if(!m_zero.InitCommon())
            throw 0;
        if(!m_one.InitCommon())
            throw 1;
        if(!m_two.InitCommon())
            throw 2;
        //...
    }
    catch(int iExc)
    {
        switch(iExc)
        {
        //...
        case 3:
            m_two.UninitCommon();
        case 2:
            m_one.UninitCommon();
        case 1:
            m_zero.UninitCommon();
        }
        return FALSE;
    }
    return TRUE;
}

BOOL CApp::Init()
{
    try
    {
        m_hSome0 = InitSome0()
        if (!m_hSome0)
            throw 0;
        m_hSome1 = InitSome1()
        if (!m_hSome1)
            throw 1;
        m_hSome2 = InitSome2()
        if (!m_hSome2)
            throw 2;
        //...
    }
    catch(int iExc)
    {
        switch(iExc)
        {
        //...
        case 3:
            Release(hSome2);
        case 2:
            Release(hSome1);
        case 1:
            Release(hSome0);
        }
        return FALSE;
    }
    return TRUE;
}

BOOL CApp::InitCommon()
{
    return initialize(m_zero, m_one, m_two);
}

BOOL CApp::InitCommon()
{
    try
    {
        auto a = init(m_zero);
        auto b = init(m_one);
        auto c = init(m_two);
        // ...
        commit(a, b, c);
    }
    catch(init_failure)
    {
        return false;
    }
    return true;
}

BOOL CApp::InitCommon()
{
    if(!m_zero.InitCommon())
        goto ERROR_zero;
    if(!m_one.InitCommon())
        goto ERROR_one;
    if(!m_two.InitCommon())
        goto ERROR_two;
    
    //...
    return true;

    ERROR_two:
        m_two.UninitCommon();
    ERROR_one:
        m_one.UninitCommon();
    ERROR_zero:
        m_zero.UninitCommon();

    return false;
}

CEM>BOOL CApp::InitCommon()
CEM>{
CEM>    try
CEM>    {
CEM>        if(!m_zero.InitCommon())
CEM>            throw 0;
CEM>        if(!m_one.InitCommon())
CEM>            throw 1;
CEM>        if(!m_two.InitCommon())
CEM>            throw 2;
CEM>        //...
CEM>    }
CEM>    catch(int iExc)
CEM>    {
CEM>        switch(iExc)
CEM>        {
CEM>        //...
CEM>        case 3:
CEM>            m_two.UninitCommon();
CEM>        case 2:
CEM>            m_one.UninitCommon();
CEM>        case 1:
CEM>            m_zero.UninitCommon();
CEM>        }
CEM>        return FALSE;
CEM>    }
CEM>    return TRUE;
CEM>}
CEM>

int opcnt = 0;
if (m_zero.InitCommon()) {
   opcnt++;
   if (m_one.InitCommon()) {
       opcnt++;
       if (m_two.InitCommon()) {
           opcnt++;
           goto OK;
       }
   }
}

switch(opcnt) {
case 3:
    m_two.UninitCommon();
case 2:
    m_one.UninitCommon();
case 1:
    m_zero.UninitCommon();
}

return FALSE;

OK:

return TRUE;