自学教程：C++ utarray_front函数代码示例

/*-----------------------------------------------------------------------------*   Read tokens from the current statement into tokensd[], to be parsed*	by state machine*----------------------------------------------------------------------------*/static void read_token(ParseCtx *ctx){	STR_DEFINE(buffer, STR_SIZE);	Sym sym_copy;	int p_index;	int expr_start_index;	p_index = ctx->p ? ctx->p - (Sym *)utarray_front(ctx->tokens) : -1;	expr_start_index = ctx->expr_start ? ctx->expr_start - (Sym *)utarray_front(ctx->tokens) : -1;	sym_copy = sym;	/* make text to be used while concatenating tokens to build an expression to parse */	switch (sym_copy.tok)	{	case TK_NUMBER:		str_sprintf(buffer, "%d", sym_copy.number);		sym_copy.tstart = token_strings_add(ctx, str_data(buffer));		sym_copy.tlen = str_len(buffer);		break;	case TK_NAME:	case TK_LABEL:	case TK_STRING:		break;	case TK_END:		sym_copy.tstart = "";		sym_copy.tlen = 0;		break;	default:;//		if (!*(sym_copy.text))//			assert(*(sym_copy.text));	}//	sym_copy.string = token_strings_add(sym.string);	utarray_push_back(ctx->tokens, &sym_copy);	ctx->p = (Sym *)utarray_front(ctx->tokens) + (p_index >= 0 ? p_index : 0);	ctx->pe = (Sym *)utarray_back(ctx->tokens) + 1;	if (sym.tok == TK_END)		ctx->eof = ctx->pe;	else		ctx->eof = NULL;	ctx->expr_start = expr_start_index >= 0 ? ((Sym *)utarray_front(ctx->tokens)) + expr_start_index : NULL;	GetSym();	STR_DELETE(buffer);}

int set_sample_tainted( dba_context* ctx ) {        const char* img;    UT_array* fblocks;    TSK_DADDR_T  st_haddr,                  ed_haddr;    TSK_DADDR_T* haddr_tuple;     UT_array* fnames;     char**    fname;    img     = get_device_image( "ide0-hd0" );    fblocks = tsk_find_haddr_by_filename( img, ctx->sample_gpath );    qemu_mutex_lock( &qemu_global_mutex );    for( haddr_tuple  = (TSK_DADDR_T*)utarray_front(fblocks);         haddr_tuple != NULL;         haddr_tuple  = (TSK_DADDR_T*)utarray_next(fblocks, haddr_tuple) ) {        st_haddr = haddr_tuple[0];        ed_haddr = haddr_tuple[1];        fnames = tsk_get_filename_by_haddr( img, st_haddr );        if( fnames == NULL )            continue;        for( fname  = (char**)utarray_front(fnames);             fname != NULL;             fname  = (char**)utarray_next(fnames, fname) ) {            if( strcasecmp(*fname, ctx->sample_gpath) != 0 )                 continue;            dift_contaminate_disk_or( st_haddr, ed_haddr - st_haddr + 1, ctx->taint.tag );            break;        }        utarray_free( fnames );    }    utarray_free( fblocks );    qemu_mutex_unlock( &qemu_global_mutex );    return 0;}

boolean IsMouseInOtherMenu(XlibMenu *xlibMenu, int x, int y){    FcitxClassicUI *classicui = xlibMenu->parent.owner;    FcitxInstance* instance = classicui->owner;    FcitxUIMenu** menupp;    UT_array* uimenus = FcitxInstanceGetUIMenus(instance);    for (menupp = (FcitxUIMenu **) utarray_front(uimenus);            menupp != NULL;            menupp = (FcitxUIMenu **) utarray_next(uimenus, menupp)        ) {        XlibMenu* otherXlibMenu = (XlibMenu*)(*menupp)->uipriv[classicui->isfallback];        if (otherXlibMenu == xlibMenu)            continue;        XWindowAttributes attr;        XGetWindowAttributes(classicui->dpy, otherXlibMenu->parent.wId, &attr);        if (attr.map_state != IsUnmapped &&                FcitxUIIsInBox(x, y, attr.x, attr.y, attr.width, attr.height)) {            return true;        }    }    XlibMenu* otherXlibMenu = classicui->mainMenuWindow;    if (otherXlibMenu == xlibMenu)        return false;    XWindowAttributes attr;    XGetWindowAttributes(classicui->dpy, otherXlibMenu->parent.wId, &attr);    if (attr.map_state != IsUnmapped &&            FcitxUIIsInBox(x, y, attr.x, attr.y, attr.width, attr.height)) {        return true;    }    return false;}

/* report to all configured destinations */void report_status(pmtr_t *cfg) {  int rc;  time_t now = time(NULL);  /* construct msg */  utstring_clear(cfg->s);  utstring_printf(cfg->s, "report %s/n", cfg->report_id);  job_t *j = NULL;  while ( (j=(job_t*)utarray_next(cfg->jobs,j))) {    if (j->respawn == 0) continue; /* don't advertise one-time jobs */    utstring_printf(cfg->s, "%s %c %u %d %s/n", j->name, j->disabled?'d':'e',                    (unsigned)(now - j->start_ts), (int)j->pid,                    *((char**)utarray_front(&j->cmdv)));  }  /* send to all dests */  int *fd=NULL;  while ( (fd=(int*)utarray_next(cfg->report,fd))) {    rc = write(*fd,utstring_body(cfg->s),utstring_len(cfg->s));    if (rc < 0 && errno != ECONNREFUSED)       syslog(LOG_INFO,"write error: %s", strerror(errno));    if (rc >= 0 && rc < utstring_len(cfg->s)) {      syslog(LOG_INFO,"incomplete write %d/%d", rc, utstring_len(cfg->s));    }  }}

void MergeRules(FcitxXkbRules* rules, FcitxXkbRules* rulesextra){    utarray_concat(rules->modelInfos, rulesextra->modelInfos);    utarray_concat(rules->optionGroupInfos, rulesextra->optionGroupInfos);    FcitxXkbLayoutInfo* layoutInfo;    UT_array toAdd;    utarray_init(&toAdd, fcitx_ptr_icd);    for (layoutInfo = (FcitxXkbLayoutInfo*) utarray_front(rulesextra->layoutInfos);         layoutInfo != NULL;         layoutInfo = (FcitxXkbLayoutInfo*) utarray_next(rulesextra->layoutInfos, layoutInfo))    {        FcitxXkbLayoutInfo* l = FindByName(rules, layoutInfo->name);        if (l) {            utarray_concat(l->languages, layoutInfo->languages);            utarray_concat(l->variantInfos, layoutInfo->variantInfos);        }        else            utarray_push_back(&toAdd, &layoutInfo);    }    unsigned int i;    for(i = 0;i < utarray_len(&toAdd);i++) {        FcitxXkbLayoutInfo* p = *(FcitxXkbLayoutInfo**)utarray_eltptr(&toAdd, i);        utarray_push_back(rules->layoutInfos, p);    }    utarray_done(&toAdd);    FcitxXkbRulesFree(rulesextra);}

FCITX_EXPORT_APIvoid FcitxUILoad(FcitxInstance* instance){    UT_array* addons = &instance->addons;    FcitxAddon *addon;    for (addon = (FcitxAddon *) utarray_front(addons);            addon != NULL;            addon = (FcitxAddon *) utarray_next(addons, addon)) {        if (addon->bEnabled && addon->category == AC_UI) {            if (FcitxUILoadInternal(instance, addon))                instance->uinormal = addon;            if (instance->uinormal != NULL)                break;        }    }    instance->ui = instance->uinormal;    if (instance->ui == NULL) {        FcitxLog(ERROR, "no usable user interface.");        return;    }    if (addon->uifallback)        instance->fallbackuiName = strdup(addon->uifallback);}

void ParsePlacement(UT_array* sps, char* placment){    UT_array* array = SplitString(placment, ';');    char** str;    utarray_clear(sps);    for(str = (char**) utarray_front(array);        str != NULL;        str = (char**) utarray_next(array, str))    {        char* s = *str;        char* p = strchr(s, ':');        if (p == NULL)            continue;        if ((strchr(s, ':') - s) > MAX_STATUS_NAME)            continue;                int len = p - s;        SkinPlacement sp;        strncpy(sp.name, s, len);        sp.name[len] = '/0';        int ret = sscanf(p+1, "%d,%d", &sp.x, &sp.y);        if (ret != 2)            continue;        utarray_push_back(sps, &sp);    }        utarray_free(array);}

int main() {  UT_array *a;  int i, *p;  utarray_new(a, &ut_int_icd);  for(i=0;i<10;i++) utarray_push_back(a,&i);  for(p=(int*)utarray_front(a); p; p=(int*)utarray_next(a,p)) printf("%d ",*p);  printf("/n");  utarray_sort(a,reverse);  while ( (p=(int*)utarray_next(a,p))) printf("%d ", *p);  printf("/n");  utarray_erase(a,3,3);  while ( (p=(int*)utarray_next(a,p))) printf("%d ", *p);  printf("/n");  utarray_erase(a,1,2);  while ( (p=(int*)utarray_next(a,p))) printf("%d ", *p);  printf("/n");  utarray_erase(a,0,1);  while ( (p=(int*)utarray_next(a,p))) printf("%d ", *p);  printf("/n");  utarray_erase(a,3,1);  while ( (p=(int*)utarray_next(a,p))) printf("%d ", *p);  printf("/n");  utarray_resize(a,5);  while ( (p=(int*)utarray_next(a,p))) printf("%d ", *p);  printf("/n");  utarray_resize(a,3);  while ( (p=(int*)utarray_next(a,p))) printf("%d ", *p);  printf("/n");  utarray_erase(a,0,3);  while ( (p=(int*)utarray_next(a,p))) printf("%d ", *p);  printf("/n");  utarray_free(a);  return 0;}

OMX_PTRtiz_vector_front (tiz_vector_t * p_vec){  assert (p_vec);  return utarray_front (p_vec->p_uta);}

char *mtex2MML_combine_row_data(UT_array **environment_data_stack){  /* if no information was provided, give a standard sizing */  if (utarray_len(*environment_data_stack) == 0) {    const char* s = "rowspacing=/"0.5ex/" rowlines=/"none/"";    char* c = (char*)malloc(strlen(s) + 1);    strcpy(c, s);    return c;  }  envdata_t *row_data_elem = (envdata_t*) utarray_front(*environment_data_stack);  char *row_spacing_data = row_data_elem->rowspacing,        *row_lines_data = row_data_elem->rowlines,         *row_attr;  UT_string *row_attr_data;  utstring_new(row_attr_data);  /* combine the row spacing and row lines data */  utstring_printf(row_attr_data, "%s%s/" %s/"", "rowspacing=/"", row_spacing_data, row_lines_data);  row_attr = string_dup(utstring_body(row_attr_data));  utarray_erase(*environment_data_stack, 0, 1);  utstring_free(row_attr_data);  return row_attr;}

boolean IsMouseInOtherMenu(XlibMenu *xlibMenu, int x, int y){    FcitxLightUI *lightui = xlibMenu->owner;    FcitxInstance* instance = lightui->owner;    FcitxUIMenu** menupp;    for (menupp = (FcitxUIMenu **) utarray_front(&instance->uimenus);            menupp != NULL;            menupp = (FcitxUIMenu **) utarray_next(&instance->uimenus, menupp)        )    {        XlibMenu* otherXlibMenu = (XlibMenu*) (*menupp)->uipriv;        if (otherXlibMenu == xlibMenu)            continue;        XWindowAttributes attr;        XGetWindowAttributes(lightui->dpy, otherXlibMenu->menuWindow, &attr);        if (attr.map_state != IsUnmapped &&                IsInBox(x, y, attr.x, attr.y, attr.width, attr.height))        {            return true;        }    }    XlibMenu* otherXlibMenu = lightui->mainMenuWindow;    if (otherXlibMenu == xlibMenu)        return false;    XWindowAttributes attr;    XGetWindowAttributes(lightui->dpy, otherXlibMenu->menuWindow, &attr);    if (attr.map_state != IsUnmapped &&            IsInBox(x, y, attr.x, attr.y, attr.width, attr.height))    {        return true;    }    return false;}

/* called when we have datagrams to read */void service_socket(pmtr_t *cfg) {  ssize_t rc;  int *fd = (int*)utarray_front(cfg->listen); assert(fd);  do {    rc = read(*fd, buf, sizeof(buf));   /* fd is non-blocking, thus */    if (rc > 0) decode_msg(cfg,buf,rc); /* we get rc==-1 after last */  } while (rc >= 0);}

void* LightUICreate(FcitxInstance* instance){    FcitxModuleFunctionArg arg;    FcitxLightUI* lightui = fcitx_utils_malloc0(sizeof(FcitxLightUI));    FcitxAddon* lightuiaddon = FcitxAddonsGetAddonByName(FcitxInstanceGetAddons(instance), FCITX_LIGHT_UI_NAME);    lightui->owner = instance;    if (!LoadLightUIConfig(lightui))    {        free(lightui);        return NULL;    }    lightui->dpy = InvokeFunction(instance, FCITX_X11, GETDISPLAY, arg);    if (lightui->dpy == NULL)    {        free(lightui);        return NULL;    }    lightui->isfallback = FcitxUIIsFallback(instance, lightuiaddon);    lightui->iScreen = DefaultScreen(lightui->dpy);    CreateFont(lightui);    lightui->protocolAtom = XInternAtom (lightui->dpy, "WM_PROTOCOLS", False);    lightui->killAtom = XInternAtom (lightui->dpy, "WM_DELETE_WINDOW", False);    /* Main Menu Initial */    FcitxMenuInit(&lightui->mainMenu);    FcitxUIMenu **menupp;    UT_array* uimenus = FcitxInstanceGetUIMenus(instance);    for (menupp = (FcitxUIMenu **) utarray_front(uimenus);            menupp != NULL;            menupp = (FcitxUIMenu **) utarray_next(uimenus, menupp)        )    {        FcitxUIMenu * menup = *menupp;        if (!menup->isSubMenu)            FcitxMenuAddMenuItem(&lightui->mainMenu, menup->name, MENUTYPE_SUBMENU, menup);    }    FcitxMenuAddMenuItem(&lightui->mainMenu, NULL, MENUTYPE_DIVLINE, NULL);    FcitxMenuAddMenuItem(&lightui->mainMenu, _("Configure"), MENUTYPE_SIMPLE, NULL);    FcitxMenuAddMenuItem(&lightui->mainMenu, _("Exit"), MENUTYPE_SIMPLE, NULL);    lightui->mainMenu.MenuAction = MainMenuAction;    lightui->mainMenu.priv = lightui;    lightui->mainMenu.mark = -1;    lightui->inputWindow = CreateInputWindow(lightui);    lightui->mainWindow = CreateMainWindow(lightui);    lightui->trayWindow = CreateTrayWindow(lightui);    lightui->mainMenuWindow = CreateMainMenuWindow(lightui);    FcitxIMEventHook resethk;    resethk.arg = lightui;    resethk.func = LightUIInputReset;    FcitxInstanceRegisterResetInputHook(instance, resethk);    return lightui;}

int mtex2MML_current_env_line_count(UT_array **environment_data_stack){  if (utarray_len(*environment_data_stack) == 0) {    return -1;  }  envdata_t *row_data_elem = (envdata_t*) utarray_front(*environment_data_stack);  return row_data_elem->line_count;}

envType mtex2MML_current_env_type(UT_array **environment_data_stack){  if (utarray_len(*environment_data_stack) == 0) {    return OTHER;  }  envdata_t *row_data_elem = (envdata_t*) utarray_front(*environment_data_stack);  return row_data_elem->environment_type;}

FcitxAddon* FcitxAddonsGetAddonByNameInternal(UT_array* addons, const char* name, boolean checkDisabled){    FcitxAddon *addon;    for (addon = (FcitxAddon *) utarray_front(addons);            addon != NULL;            addon = (FcitxAddon *) utarray_next(addons, addon)) {        if ((checkDisabled || addon->bEnabled) && strcmp(name, addon->name) == 0)            return addon;    }    return NULL;}

boolean SwitchToEng(FcitxAutoEngState* autoEngState, char *str){    AUTO_ENG*       autoeng;    for (autoeng = (AUTO_ENG *) utarray_front(autoEngState->autoEng);            autoeng != NULL;            autoeng = (AUTO_ENG *) utarray_next(autoEngState->autoEng, autoeng))        if (!strcmp(str, autoeng->str))            return true;    return false;}

static void check_flags(Cmdline *cmdline, Cmdstr *cmd){  Token *fst = (Token*)utarray_front(cmdline->tokens);  char *exstr = token_val(fst, VAR_STRING);  if (!exstr || cmd_conditional())    return;  if (exstr[0] == '!')    cmd->exec = true;}

FCITX_EXPORT_APIboolean FcitxInstanceCheckTimeoutById(FcitxInstance *instance, uint64_t id){    TimeoutItem *ti;    for (ti = (TimeoutItem*)utarray_front(&instance->timeout);ti;         ti = (TimeoutItem*)utarray_next(&instance->timeout, ti)) {        if (ti->idx == id)            return true;    }    return false;}

FcitxAddon* find_addon_by_name(UT_array* array, gchar* name){    FcitxAddon* addon = NULL;    for (addon = (FcitxAddon *) utarray_front(array);         addon != NULL;         addon = (FcitxAddon *) utarray_next(array, addon)) {        if (strcmp(addon->name, name) == 0)            break;    }    return addon;}

void FcitxInstanceFillAddonOwner(FcitxInstance* instance, FcitxAddon* addonHead){    /* FIXME: a walkaround for not have instance in function FcitxModuleInvokeFunction */    FcitxAddon* addon;    if (addonHead)        addon = addonHead;    else        addon = (FcitxAddon *) utarray_front(&instance->addons);    for (; addon != NULL; addon = (FcitxAddon *) utarray_next(&instance->addons, addon)) {        addon->owner = instance;    }}

static inlineFcitxXkbLayoutInfo* FindByName(FcitxXkbRules* rules, const char* name) {    FcitxXkbLayoutInfo* layoutInfo;    for (layoutInfo = (FcitxXkbLayoutInfo*) utarray_front(rules->layoutInfos);         layoutInfo != NULL;         layoutInfo = (FcitxXkbLayoutInfo*) utarray_next(rules->layoutInfos, layoutInfo))    {        if (strcmp(layoutInfo->name, name) == 0)            break;    }    return layoutInfo;}

FCITX_EXPORT_APIboolean FcitxInstanceCheckTimeoutByFunc(FcitxInstance* instance, FcitxTimeoutCallback callback){    TimeoutItem* ti;    for (ti = (TimeoutItem*) utarray_front(&instance->timeout);         ti != NULL;         ti = (TimeoutItem*) utarray_next(&instance->timeout, ti))    {        if (ti->callback == callback)            return true;    }    return false;}

void CloseOtherSubMenuWindow(XlibMenu *xlibMenu, XlibMenu* subMenu){    FcitxClassicUI* classicui = xlibMenu->parent.owner;    FcitxMenuItem *menu;    for (menu = (FcitxMenuItem *) utarray_front(&xlibMenu->menushell->shell);            menu != NULL;            menu = (FcitxMenuItem *) utarray_next(&xlibMenu->menushell->shell, menu)        ) {        if (menu->type == MENUTYPE_SUBMENU && menu->subMenu && menu->subMenu->uipriv[classicui->isfallback] != subMenu) {            CloseAllSubMenuWindow((XlibMenu *)menu->subMenu->uipriv[classicui->isfallback]);        }    }}

FCITX_EXPORT_APIint fcitx_utils_string_list_contains(UT_array* list, const char* scmp){    char** str;    for (str = (char**) utarray_front(list);         str != NULL;         str = (char**) utarray_next(list, str))    {        if (strcmp(scmp, *str) == 0)            return 1;    }    return 0;}

void IMSelectorGetCands(IMSelector* imselector){    FcitxInstance* instance = imselector->owner;    FcitxInputState *input = FcitxInstanceGetInputState(instance);    FcitxIM* pim;    UT_array* imes = FcitxInstanceGetIMEs(instance);    FcitxInstanceCleanInputWindow(instance);    FcitxCandidateWordSetPageSize(FcitxInputStateGetCandidateList(input), 10);    FcitxCandidateWordSetChoose(FcitxInputStateGetCandidateList(input), DIGIT_STR_CHOOSE);    FcitxInputStateSetShowCursor(input, false);    FcitxInputContext* ic = FcitxInstanceGetCurrentIC(instance);    FcitxInputContext2* ic2 = (FcitxInputContext2*) ic;    if (!ic)        return;    FcitxMessagesAddMessageStringsAtLast(FcitxInputStateGetAuxUp(input),                                         MSG_TIPS, imselector->global ?                                         _("Select global input method: ") :                                         _("Select local input method: "));    if (ic2->imname) {        int idx = FcitxInstanceGetIMIndexByName(instance, ic2->imname);        FcitxIM* im = (FcitxIM*) utarray_eltptr(imes, idx);        if (im) {            FcitxMessagesAddMessageAtLast(FcitxInputStateGetAuxUp(input), MSG_TIPS, _("Current local input method is %s"), im->strName);        }    }    else {        FcitxMessagesAddMessageStringsAtLast(FcitxInputStateGetAuxUp(input),                                             MSG_TIPS,                                             _("No local input method"));    }    for (pim = (FcitxIM *) utarray_front(imes);            pim != NULL;            pim = (FcitxIM *) utarray_next(imes, pim)) {        FcitxCandidateWord candWord;        candWord.callback = IMSelectorGetCand;        candWord.owner = imselector;        candWord.strExtra = NULL;        if (ic2->imname && strcmp(ic2->imname, pim->uniqueName) == 0) {            candWord.priv = NULL;            candWord.strWord = strdup(_("Clear local input method"));        }        else {            candWord.priv = strdup(pim->uniqueName);            candWord.strWord = strdup(pim->strName);        }        candWord.wordType = MSG_OTHER;        FcitxCandidateWordAppend(FcitxInputStateGetCandidateList(input), &candWord);    }}

void* XimConsumeQueue(void* arg, FcitxModuleFunctionArg args){    FcitxXimFrontend* xim = arg;    if (!xim->ims)        return NULL;    XimQueue* item;    size_t len = utarray_len(xim->queue);    for (item = (XimQueue*) utarray_front(xim->queue);         item != NULL;         item = (XimQueue*) utarray_next(xim->queue, item))    {        switch(item->type) {        case XCT_FORWARD:            {                IMForwardEvent(xim->ims, item->ptr);            }            break;        case XCT_CALLCALLBACK:            {                IMCallCallback(xim->ims, item->ptr);                IMPreeditCBStruct* pcb = (IMPreeditCBStruct*) item->ptr;                if (pcb->major_code == XIM_PREEDIT_DRAW) {                    XFree(pcb->todo.draw.text->string.multi_byte);                    free(pcb->todo.draw.text);                }            }            break;        case XCT_COMMIT:            {                IMCommitString(xim->ims, item->ptr);                IMCommitStruct* cms = (IMCommitStruct*) item->ptr;                XFree(cms->commit_string);            }            break;        case XCT_PREEDIT_START:            IMPreeditStart(xim->ims, item->ptr);            break;        case XCT_PREEDIT_END:            IMPreeditEnd(xim->ims, item->ptr);            break;        }        free(item->ptr);    }    utarray_clear(xim->queue);    if (len)        FcitxInstanceSetRecheckEvent(xim->owner);    return NULL;}

void* RunInstance(void* arg){    FcitxInstance* instance = (FcitxInstance*) arg;    while (1) {        FcitxAddon** pmodule;        do {            instance->uiflag = UI_NONE;            for (pmodule = (FcitxAddon**) utarray_front(&instance->eventmodules);                    pmodule != NULL;                    pmodule = (FcitxAddon**) utarray_next(&instance->eventmodules, pmodule)) {                FcitxModule* module = (*pmodule)->module;                module->ProcessEvent((*pmodule)->addonInstance);            }            if (instance->uiflag & UI_MOVE)                FcitxUIMoveInputWindowReal(instance);            if (instance->uiflag & UI_UPDATE)                FcitxUIUpdateInputWindowReal(instance);        } while (instance->uiflag != UI_NONE);        FD_ZERO(&instance->rfds);        FD_ZERO(&instance->wfds);        FD_ZERO(&instance->efds);        instance->maxfd = 0;        for (pmodule = (FcitxAddon**) utarray_front(&instance->eventmodules);                pmodule != NULL;                pmodule = (FcitxAddon**) utarray_next(&instance->eventmodules, pmodule)) {            FcitxModule* module = (*pmodule)->module;            module->SetFD((*pmodule)->addonInstance);        }        if (instance->maxfd == 0)            break;        select(instance->maxfd + 1, &instance->rfds, &instance->wfds, &instance->efds, NULL);    }    return NULL;}

void CloseAllMenuWindow(FcitxClassicUI *classicui){    FcitxInstance* instance = classicui->owner;    FcitxUIMenu** menupp;    UT_array* uimenus = FcitxInstanceGetUIMenus(instance);    for (menupp = (FcitxUIMenu **) utarray_front(uimenus);            menupp != NULL;            menupp = (FcitxUIMenu **) utarray_next(uimenus, menupp)        ) {        XlibMenu* xlibMenu = (XlibMenu*)(*menupp)->uipriv[classicui->isfallback];        XlibMenuHide(xlibMenu);    }    XlibMenuHide(classicui->mainMenuWindow);}

FCITX_EXPORT_APIFcitxUIComplexStatus *FcitxUIGetComplexStatusByName(FcitxInstance* instance, const char* name){    UT_array* uicompstats = &instance->uicompstats;    FcitxUIComplexStatus *compstatus;    for (compstatus = (FcitxUIComplexStatus *) utarray_front(uicompstats);         compstatus != NULL;         compstatus = (FcitxUIComplexStatus *) utarray_next(uicompstats, compstatus))        if (strcmp(compstatus->name, name) == 0)            break;    return compstatus;}