Example #1
0
pantheios_be_init(
    PAN_CHAR_T const*   processIdentity
,   void*               reserved
,   void**              ptoken
)
{
    size_t const    numBackEnds     =   pantheios_be_N_countBackEnds_();
    size_t          n;
    size_t          numSucceeded    =   0;
    int             res;
    pan_be_N_t*     terminalBackEnd =   &PAN_BE_N_BACKEND_LIST[numBackEnds];

    STLSOFT_SUPPRESS_UNUSED(reserved);

    PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != ptoken, "token pointer may not be null");

    *ptoken = NULL;

    if(0 == numBackEnds)
    {
        res = PANTHEIOS_BE_INIT_RC_NO_BACKENDS_SPECIFIED;
    }
    else
    {
        res = 0;

        for(n = 0; n < numBackEnds; ++n)
        {
            pan_be_N_t* backEnd = &PAN_BE_N_BACKEND_LIST[n];

            PANTHEIOS_CONTRACT_ENFORCE_STATIC_DATA_APPL_DEF(0 != backEnd->backEndId, "be.N requires non-0 backEndId for all back-ends");

            if(-1 == backEnd->backEndId)
            {
                backEnd->backEndId = pantheios_getNextBackEndId();
            }

            if( PANTHEIOS_BE_N_F_INIT_ONLY_IF_PREVIOUS_FAILED == (PANTHEIOS_BE_N_F_INIT_ONLY_IF_PREVIOUS_FAILED & backEnd->flags) &&
                0 != numSucceeded)
            {
                backEnd->flags |= PANTHEIOS_BE_N_F_IGNORE_INIT_FAILURE;

                continue;
            }
            else
            {
                res = (*backEnd->pfnInit)(processIdentity, backEnd->backEndId, NULL, NULL, &backEnd->token);
            }

            if(0 == res)
            {
                /* Initialisation of the given back-end has succeeded, so
                 * remove PANTHEIOS_BE_N_F_IGNORE_INIT_FAILURE, if present.
                 */
                backEnd->flags &= ~(PANTHEIOS_BE_N_F_IGNORE_INIT_FAILURE);

                ++numSucceeded;

                if(terminalBackEnd->severityCeiling < backEnd->severityCeiling)
                {
                    terminalBackEnd->severityCeiling = backEnd->severityCeiling;
                }
            }
            else
            {
                if(PANTHEIOS_BE_N_F_IGNORE_INIT_FAILURE & backEnd->flags)
                {
                    /* Ignore failure. */
                    res = 0;
                }
                else
                {
                    break;
                }
            }
        }

        if(0 != res)
        {
            for(; 0 != n; --n)
            {
                pan_be_N_t* backEnd = &PAN_BE_N_BACKEND_LIST[n - 1];

                if(PANTHEIOS_BE_N_F_IGNORE_INIT_FAILURE & backEnd->flags)
                {
                    /* Was not initialised. */
                }
                else
                {
                    (*backEnd->pfnUninit)(backEnd->token);
                }
            }
        }
        else if(0 == numSucceeded)
        {
            res = PANTHEIOS_BE_INIT_RC_ALL_BACKEND_INITS_FAILED;
        }
    }

    return res;
}
int main(int argc, char *argv[])
{
    int bVerbose    =   1;

    if(pantheios_init() < 0)
    {
        return EXIT_FAILURE;
    }
    else
    {
        pantheios_init();

        pantheios_init();
        pantheios_uninit();

        pantheios_init();
        pantheios_uninit();


        pantheios_getNextBackEndId();

        { int i; for(i = 1; i < argc; ++i)
        {
            char const  *const  arg =   argv[i];

            if(arg[0] == '-')
            {
                if(arg[1] == '-')
                {
                    /* -- arguments */
                    usage(1, "Invalid argument(s) specified", i, argc, argv);
                }
                else
                {
                    /* - arguments */
                    switch(arg[1])
                    {
                        case    '?':
                            usage(1, NULL, -1, argc, argv);
                            break;
                        case    's':
                            bVerbose    =   0;
                            break;
                        case    'v':
                            bVerbose    =   1;
                            break;
                        default:
                            usage(1, "Invalid argument(s) specified", i, argc, argv);
                            break;
                    }
                }
            }
            else
            {
                /* other arguments */
                usage(1, "Invalid argument(s) specified", i, argc, argv);
            }
        }}

        pantheios_uninit();

        pantheios_uninit();

        return EXIT_SUCCESS;
    }
}