Esempio n. 1
0
int GUTHTHILA_CALL
guththila_tok_list_init(
    guththila_tok_list_t * tok_list,
    const axutil_env_t * env)
{
    int i = 0;
    tok_list->list = (guththila_token_t **)AXIS2_MALLOC(env->allocator, sizeof(guththila_token_t *)
        * GUTHTHILA_TOK_DEF_LIST_SIZE);
    if(tok_list->list && guththila_stack_init(&tok_list->fr_stack, env))
    {
        tok_list->capacity = (int *)AXIS2_MALLOC(env->allocator, sizeof(int)
            * GUTHTHILA_TOK_DEF_LIST_SIZE);
        if(tok_list->capacity)
        {
            tok_list->no_list = GUTHTHILA_TOK_DEF_LIST_SIZE;
            tok_list->list[0] = (guththila_token_t *)AXIS2_MALLOC(env->allocator,
                sizeof(guththila_token_t) * GUTHTHILA_TOK_DEF_SIZE);
            for(i = 0; i < GUTHTHILA_TOK_DEF_SIZE; i++)
            {
                guththila_stack_push(&tok_list->fr_stack, &tok_list->list[0][i], env);
            }
            tok_list->capacity[0] = GUTHTHILA_TOK_DEF_SIZE;
            tok_list->cur_list = 0;
            tok_list->no_list = GUTHTHILA_TOK_DEF_LIST_SIZE;
            return GUTHTHILA_SUCCESS;
        }
    }
    return GUTHTHILA_FAILURE;
}
guththila_namespace_list_t *GUTHTHILA_CALL
guththila_namespace_list_create(const axutil_env_t * env) 
{
    int i = 0;
    guththila_namespace_list_t * namesp_list =
        (guththila_namespace_list_t *) AXIS2_MALLOC(env->allocator,sizeof(guththila_namespace_list_t));

    if (!namesp_list)
        return NULL;

    namesp_list->list =
        (guththila_namespace_t *) AXIS2_MALLOC(env->allocator,sizeof(guththila_namespace_t) *
                                               GUTHTHILA_NAMESPACE_DEF_SIZE);

    if (namesp_list->list && guththila_stack_init(&namesp_list->fr_stack, env))
    {
        namesp_list->capacity = GUTHTHILA_NAMESPACE_DEF_SIZE;
        namesp_list->size = 0;
        for (i = 0; i < GUTHTHILA_NAMESPACE_DEF_SIZE; i++)
        {
            guththila_stack_push(&namesp_list->fr_stack, namesp_list->list + i,env);
        }
        return namesp_list;
    }
    return NULL;
}
int GUTHTHILA_CALL
guththila_namespace_list_grow(guththila_namespace_list_t * namesp_list,int addition,const axutil_env_t * env) 
{
    int i = 0;
    if (addition > 0 || (addition < 0 && namesp_list->capacity + addition > 0 &&
          namesp_list->capacity + addition >= namesp_list->size))
    {
            namesp_list->list =
            (guththila_namespace_t *) realloc(namesp_list->list,
                                              sizeof(guththila_namespace_t) *
                                              (namesp_list->capacity + addition));
        if (namesp_list->list)
        {
            for (i = namesp_list->capacity;i < namesp_list->capacity + addition; i++)
            {
                guththila_stack_push(&namesp_list->fr_stack,namesp_list->list + i, env);
            }
            namesp_list->capacity += addition;
        }
        else
        {
            return GUTHTHILA_FAILURE;
        }
    }
    return 0;
}
Esempio n. 4
0
int GUTHTHILA_CALL
guththila_tok_list_release_token(
    guththila_tok_list_t * tok_list,
    guththila_token_t * token,
    const axutil_env_t * env)
{
    return guththila_stack_push(&tok_list->fr_stack, token, env);
}
Esempio n. 5
0
int GUTHTHILA_CALL
guththila_tok_list_grow(
    guththila_tok_list_t * tok_list,
    const axutil_env_t * env)
{
    int i = 0;

    if(tok_list->cur_list < tok_list->no_list - 1)
    {
        int cur = ++tok_list->cur_list;
        int cur_cap = tok_list->capacity[cur - 1] * 2;
        guththila_token_t *list = (guththila_token_t *)AXIS2_MALLOC(env->allocator,
            sizeof(guththila_token_t) * (size_t)cur_cap);
        for(i = 0; i < cur_cap; ++i)
        {
            guththila_stack_push(&tok_list->fr_stack, &list[i], env);
        }
        tok_list->capacity[cur] = cur_cap;
        tok_list->list[cur] = list;
        return GUTHTHILA_SUCCESS;
    }
    else
    {
        guththila_token_t ** list = NULL;
        int *capacity = NULL;
        list = (guththila_token_t **)AXIS2_MALLOC(env->allocator, sizeof(guththila_token_t *)
            * (size_t)tok_list->no_list * 2);
        capacity = (int *)AXIS2_MALLOC(env->allocator, sizeof(int) * (size_t)tok_list->no_list * 2);
        if(list)
        {
            int cur_list = tok_list->cur_list;
            for(i = 0; i <= cur_list; ++i)
            {
                list[i] = tok_list->list[i];
                capacity[i] = tok_list->capacity[i];
            }
            tok_list->no_list = tok_list->no_list * 2;
            AXIS2_FREE(env->allocator, tok_list->list);
            tok_list->list = list;
            AXIS2_FREE(env->allocator, tok_list->capacity);
            tok_list->capacity = capacity;
            guththila_tok_list_grow(tok_list, env);
        }
    }
    return GUTHTHILA_FAILURE;
}
int GUTHTHILA_CALL
guththila_namespace_list_init(guththila_namespace_list_t * namesp_list,const axutil_env_t * env) 
{
    int i = 0;
    namesp_list->list =
        (guththila_namespace_t *) AXIS2_MALLOC(env->allocator,
                                               sizeof(guththila_namespace_t) *
                                               GUTHTHILA_NAMESPACE_DEF_SIZE);
    if (namesp_list->list && guththila_stack_init(&namesp_list->fr_stack, env))
    {
        namesp_list->capacity = GUTHTHILA_NAMESPACE_DEF_SIZE;
        namesp_list->size = 0;
        for (i = 0; i < GUTHTHILA_NAMESPACE_DEF_SIZE; i++)
        {
            guththila_stack_push(&namesp_list->fr_stack, namesp_list->list + i,env);
        }
        return GUTHTHILA_SUCCESS;
    }
    return GUTHTHILA_FAILURE;
}