Exemple #1
0
FCITX_EXPORT_API UT_array*
fcitx_utils_string_list_append_no_copy(UT_array *list, char *str)
{
    utarray_extend_back(list);
    *(char**)utarray_back(list) = str;
    return list;
}
Exemple #2
0
/* Create a new category with name <cat_name>.
 * The new category is pushed at the back of cat_table.
 * Aslo, a new hash entry is added for the category in cat_hash.
 * Return the newly created category.
 */
static cat_table_entry_t *MPIR_T_cat_create(const char *cat_name)
{
    int cat_idx;
    cat_table_entry_t *cat;
    name2index_hash_t *hash_entry;

    /* New a category */
    utarray_extend_back(cat_table);
    cat =(cat_table_entry_t *)utarray_back(cat_table);
    cat->name = MPL_strdup(cat_name);
    cat->desc = NULL;
    utarray_new(cat->cvar_indices, &ut_int_icd);
    utarray_new(cat->pvar_indices, &ut_int_icd);
    utarray_new(cat->subcat_indices, &ut_int_icd);

    /* Record <cat_name, cat_idx> in cat_hash */
    cat_idx = utarray_len(cat_table) - 1;
    hash_entry = MPL_malloc(sizeof(name2index_hash_t));
    MPIU_Assert(hash_entry);
    /* Need not to Strdup cat_name, since cat_table and cat_hash co-exist */
    hash_entry->name = cat_name;
    hash_entry->idx = cat_idx;
    HASH_ADD_KEYPTR(hh, cat_hash, hash_entry->name,
                    strlen(hash_entry->name), hash_entry);

    return cat;
}
Exemple #3
0
/* code borrow from kde-workspace/kcontrol/keyboard/xkb_rules.cpp */
void RulesHandlerStartElement(void *ctx, const xmlChar *name,
                              const xmlChar **atts)
{
    FcitxXkbRulesHandler* ruleshandler = (FcitxXkbRulesHandler*) ctx;
    FcitxXkbRules* rules = ruleshandler->rules;
    utarray_push_back(ruleshandler->path, &name);

    char* strPath = fcitx_utils_join_string_list(ruleshandler->path, '/');
    if ( StringEndsWith(strPath, "layoutList/layout/configItem") ) {
        utarray_extend_back(rules->layoutInfos);
    }
    else if ( StringEndsWith(strPath, "layoutList/layout/variantList/variant") ) {
        FcitxXkbLayoutInfo* layoutInfo = (FcitxXkbLayoutInfo*) utarray_back(rules->layoutInfos);
        utarray_extend_back(layoutInfo->variantInfos);
    }
    else if ( StringEndsWith(strPath, "modelList/model") ) {
        utarray_extend_back(rules->modelInfos);
    }
    else if ( StringEndsWith(strPath, "optionList/group") ) {
        utarray_extend_back(rules->optionGroupInfos);
        FcitxXkbOptionGroupInfo* optionGroupInfo = (FcitxXkbOptionGroupInfo*) utarray_back(rules->optionGroupInfos);
        int i = 0;
        while(atts && atts[i*2] != 0) {
            if (strcmp(XMLCHAR_CAST atts[i*2], "allowMultipleSelection") == 0) {
                optionGroupInfo->exclusive = (strcmp(XMLCHAR_CAST atts[i*2 + 1], "true") != 0);
            }
            i++;
        }
    }
    else if ( StringEndsWith(strPath, "optionList/group/option") ) {
        FcitxXkbOptionGroupInfo* optionGroupInfo = (FcitxXkbOptionGroupInfo*) utarray_back(rules->optionGroupInfos);
        utarray_extend_back(optionGroupInfo->optionInfos);
    }
    else if ( strcmp(strPath, "xkbConfigRegistry") == 0 ) {
        int i = 0;
        while(atts && atts[i*2] != 0) {
            if (strcmp(XMLCHAR_CAST atts[i*2], "version") == 0 && strlen(XMLCHAR_CAST atts[i*2 + 1]) != 0) {
                rules->version = strdup(XMLCHAR_CAST atts[i*2 + 1]);
            }
            i++;
        }
    }
    free(strPath);
}
Exemple #4
0
/* A low level, generic and internally used interface to register
 * a pvar to MPIR_T. Other modules should use interfaces defined
 * for concrete pvar classes.
 *
 * IN: varclass, MPI_T_PVAR_CLASS_*
 * IN: dtype, MPI datatype for this pvar
 * IN: name, Name of the pvar
 * IN: addr, Pointer to the pvar if known at registeration, otherwise NULL.
 * IN: count, # of elements of this pvar if known at registeration, otherwise 0.
 * IN: etype, MPI_T_enum or MPI_T_ENUM_NULL
 * IN: verb, MPI_T_PVAR_VERBOSITY_*
 * IN: binding, MPI_T_BIND_*
 * IN: flags, Bitwise OR of MPIR_T_R_PVAR_FLAGS_{}
 * IN: get_value, If not NULL, it is a callback to read the pvar.
 * IN: get_count, If not NULL, it is a callback to read count of the pvar.
 * IN: cat, Catogery name of the pvar
 * IN: desc, Description of the pvar
 */
void MPIR_T_PVAR_REGISTER_impl(
    int varclass, MPI_Datatype dtype, const char* name, void *addr, int count,
    MPIR_T_enum_t *etype, int verb, int binding, int flags,
    MPIR_T_pvar_get_value_cb get_value, MPIR_T_pvar_get_count_cb get_count,
    const char * cat, const char * desc)
{
    name2index_hash_t *hash_entry;
    pvar_table_entry_t *pvar;
    int pvar_idx;
    int seq = varclass - MPIR_T_PVAR_CLASS_FIRST;

    /* Check whether this is a replicated pvar, whose name is unique per class */
    HASH_FIND_STR(pvar_hashs[seq], name, hash_entry);

    if (hash_entry != NULL) {
        /* Found it, the pvar already exists */
        pvar_idx = hash_entry->idx;
        pvar = (pvar_table_entry_t *)utarray_eltptr(pvar_table, pvar_idx);
        /* Should never override an existing & active var */
        MPIU_Assert(pvar->active != TRUE);
        pvar->active = TRUE;
        /* FIXME: Do we need to check consistency between the old and new? */
    } else {
        /* Not found, so push the pvar to back of pvar_table */
        utarray_extend_back(pvar_table);
        pvar = (pvar_table_entry_t *)utarray_back(pvar_table);
        pvar->active = TRUE;
        pvar->varclass = varclass;
        pvar->datatype = dtype;
        pvar->name = MPL_strdup(name);
        MPIU_Assert(pvar->name);
        pvar->addr = addr;
        pvar->count = count;
        pvar->enumtype = etype;
        pvar->verbosity = verb;
        pvar->bind = binding;
        pvar->flags = flags;
        pvar->get_value = get_value;
        pvar->get_count = get_count;
        pvar->desc = MPL_strdup(desc);
        MPIU_Assert(pvar->desc);

        /* Record <name, index> in hash table */
        pvar_idx = utarray_len(pvar_table) - 1;
        hash_entry = MPL_malloc(sizeof(name2index_hash_t));
        MPIU_Assert(hash_entry);
        /* Need not to Strdup name, since pvar_table and pvar_hashs co-exist */
        hash_entry->name = name;
        hash_entry->idx = pvar_idx;
        HASH_ADD_KEYPTR(hh, pvar_hashs[seq], hash_entry->name,
                        strlen(hash_entry->name), hash_entry);

        /* Add the pvar to a category */
        MPIR_T_cat_add_pvar(cat, utarray_len(pvar_table)-1);
    }
}
Exemple #5
0
/* Add an item to an exisiting enum.
 * IN: handle, handle to the enum
 * IN: item_name, name of the item
 * IN: item_value, value associated with item_name
 */
void MPIR_T_enum_add_item(MPI_T_enum handle, const char *item_name, int item_value)
{
    enum_item_t *item;

    MPIU_Assert(handle);
    MPIU_Assert(item_name);

    utarray_extend_back(handle->items);
    item = (enum_item_t *)utarray_back(handle->items);
    item->name = MPL_strdup(item_name);
    MPIU_Assert(item->name);
    item->value = item_value;
}
Exemple #6
0
/* Create an enum.
 * IN: enum_name, name of the enum
 * OUT: handle, handle of the enum
 */
void MPIR_T_enum_create(const char *enum_name, MPI_T_enum *handle)
{
    MPIR_T_enum_t *e;
    static const UT_icd enum_item_icd = {sizeof(enum_item_t), NULL, NULL, NULL};

    MPIU_Assert(enum_name);
    MPIU_Assert(handle);

    utarray_extend_back(enum_table);
    e = (MPIR_T_enum_t *)utarray_back(enum_table);
    e->name = MPL_strdup(enum_name);
    MPIU_Assert(e->name);
#ifdef HAVE_ERROR_CHECKING
    e->kind = MPIR_T_ENUM_HANDLE;
#endif
    utarray_new(e->items, &enum_item_icd);
    (*handle) = e;
}
Exemple #7
0
int main() {
  UT_array *a;
  int i, *p=NULL;
  utarray_new(a, &ut_int_icd);
  for(i=0;i<10;i++) utarray_push_back(a,&i);
  utarray_pop_back(a);
  utarray_erase(a,0,1);
  while ( (p=(int*)utarray_next(a,p)) != NULL ) printf("%d ",*p); printf("\n");
  i = 100;
  utarray_insert(a,&i,3);
  while ( (p=(int*)utarray_next(a,p)) != NULL ) printf("%d ",*p); printf("\n");
  utarray_extend_back(a);
  p = (int*)utarray_back(a);
  *p = 1000;
  p = NULL;
  while ( (p=(int*)utarray_next(a,p)) != NULL ) printf("%d ",*p); printf("\n");
  utarray_clear(a);
  utarray_free(a);
  return 0;
}
Exemple #8
0
Fichier : Array.c Projet : awm/atp
static Value *findOrCreateEntry(ATP_Array *p_array, unsigned int p_index)
{
    Value *l_entry;
    unsigned int l_length = utarray_len(CAST(p_array));
    if (p_index > l_length)
    {
        ERR("Index out of bounds\n");
        return NULL;
    }
    else if (p_index == l_length)
    {
        utarray_extend_back(CAST(p_array));
        l_entry = (Value *) utarray_back(CAST(p_array));
    }
    else
    {
        l_entry = (Value *) utarray_eltptr(CAST(p_array), p_index);
    }

    return l_entry;
}
Exemple #9
0
/* A low level, generic and internally used interface to register
 * a cvar to the MPIR_T.
 *
 * IN: dtype, MPI datatype for this cvar
 * IN: name, Name of the cvar
 * IN: addr, Pointer to the cvar if known at registeration, otherwise NULL.
 * IN: count, # of elements of this cvar if known at registeration, otherwise 0.
 * IN: etype, MPI_T_enum or MPI_T_ENUM_NULL
 * IN: verb, MPI_T_PVAR_VERBOSITY_*
 * IN: binding, MPI_T_BIND_*
 * IN: Scope, MPI_T_SCOPE_*
 * IN: get_addr, If not NULL, it is a callback to get address of the cvar.
 * IN: get_count, If not NULL, it is a callback to read count of the cvar.
 * IN: cat, Catogery name of the cvar
 * IN: desc, Description of the cvar
 */
void MPIR_T_CVAR_REGISTER_impl(
    MPI_Datatype dtype, const char* name, const void *addr, int count,
    MPIR_T_enum_t *etype, MPIR_T_verbosity_t verb, MPIR_T_bind_t binding,
    MPIR_T_scope_t scope, MPIR_T_cvar_get_addr_cb get_addr,
    MPIR_T_cvar_get_count_cb get_count, MPIR_T_cvar_value_t defaultval,
    const char *cat, const char * desc)
{
    name2index_hash_t *hash_entry;
    cvar_table_entry_t *cvar;
    int cvar_idx;

    /* Check whether this is a replicated cvar, whose name is unique. */
    HASH_FIND_STR(cvar_hash, name, hash_entry);

    if (hash_entry != NULL) {
        /* Found it, the cvar already exists */
        cvar_idx = hash_entry->idx;
        cvar = (cvar_table_entry_t *)utarray_eltptr(cvar_table, cvar_idx);
        /* Should never override an existing & active var */
        MPIU_Assert(cvar->active != TRUE);
        cvar->active = TRUE;
        /* FIXME: Do we need to check consistency between the old and new? */
    } else {
        /* Not found, so push the cvar to back of cvar_table */
        utarray_extend_back(cvar_table);
        cvar = (cvar_table_entry_t *)utarray_back(cvar_table);
        cvar->active = TRUE;
        cvar->datatype = dtype;
        cvar->name = MPL_strdup(name);
        MPIU_Assert(cvar->name);
        if (dtype != MPI_CHAR) {
            cvar->addr = (void *)addr;
        } else {
            cvar->addr = MPL_malloc(count);
            MPIU_Assert(cvar->addr);
            if (defaultval.str == NULL) {
                ((char *)(cvar->addr))[0] = '\0';
            } else {
                /* Use greater (>), since count includes the terminating '\0', but strlen does not */
                MPIU_Assert(count > strlen(defaultval.str));
                strcpy(cvar->addr, defaultval.str);
            }
        }
        cvar->count = count;
        cvar->verbosity = verb;
        cvar->bind = binding;
        cvar->scope = scope;
        cvar->get_addr = get_addr;
        cvar->get_count = get_count;
        cvar->defaultval = defaultval;
        cvar->desc = MPL_strdup(desc);
        MPIU_Assert(cvar->desc);

        /* Record <name, index> in hash table */
        cvar_idx = utarray_len(cvar_table) - 1;
        hash_entry = MPL_malloc(sizeof(name2index_hash_t));
        MPIU_Assert(hash_entry);
        /* Need not to Strdup name, since cvar_table and cvar_hash co-exist */
        hash_entry->name =name;
        hash_entry->idx = cvar_idx;
        HASH_ADD_KEYPTR(hh, cvar_hash, hash_entry->name,
                        strlen(hash_entry->name), hash_entry);

        /* Add the cvar to a category */
        MPIR_T_cat_add_cvar(cat, cvar_idx);
    }
}
Exemple #10
0
FcitxAddon* FcitxAddonsLoadInternal(UT_array* addons, boolean reloadIM)
{
    char **addonPath;
    size_t len;
    size_t start;
    if (!reloadIM)
        utarray_clear(addons);

    start = utarray_len(addons);

    FcitxStringHashSet* sset = FcitxXDGGetFiles("addon", NULL, ".conf");
    addonPath = FcitxXDGGetPathWithPrefix(&len, "addon");
    char *paths[len];
    HASH_FOREACH(string, sset, FcitxStringHashSet) {
        // FIXME: if it will cause realloc, then it's evil for fcitx 4.2 series
        if (reloadIM && addons->i == addons->n) {
            break;
        }
        
        int i;
        for (i = len - 1; i >= 0; i--) {
            fcitx_utils_alloc_cat_str(paths[i], addonPath[len - i - 1],
                                      "/", string->name);
            FcitxLog(DEBUG, "Load Addon Config File:%s", paths[i]);
        }
        FcitxConfigFile* cfile = FcitxConfigParseMultiConfigFile(paths, len, FcitxAddonGetConfigDesc());
        if (cfile) {
            utarray_extend_back(addons);
            FcitxAddon *a = (FcitxAddon*) utarray_back(addons);
            utarray_init(&a->functionList, fcitx_ptr_icd);
            FcitxAddonConfigBind(a, cfile, FcitxAddonGetConfigDesc());
            FcitxConfigBindSync((FcitxGenericConfig*)a);
            FcitxLog(DEBUG, _("Addon Config %s is %s"), string->name, (a->bEnabled) ? "Enabled" : "Disabled");
            boolean error = false;
            if (reloadIM) {
                if (a->category !=  AC_INPUTMETHOD)
                    error = true;
            }
            /* if loaded, don't touch the old one */
            if (FcitxAddonsGetAddonByNameInternal(addons, a->name, true) != a)
                error = true;

            if (error)
                utarray_pop_back(addons);
            else
                FcitxLog(INFO, _("Load Addon Config File:%s"), string->name);
        }

        for (i = len - 1;i >= 0;i--) {
            free(paths[i]);
        }
    }
    FcitxXDGFreePath(addonPath);

    fcitx_utils_free_string_hash_set(sset);

    size_t to = utarray_len(addons);
    utarray_sort_range(addons, AddonPriorityCmp, start, to);

    return (FcitxAddon*)utarray_eltptr(addons, start);
}