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

void place( int /* item index */ pos,            UT_array /*of int */*hashv,            UT_array /*of int */*xv,            UT_array /*of int */*yv) {  int x=0, y=0, e, p;  if (pos == 0) goto done; // place first one at origin  /*prefer to attach this hexagon to predecessor edge based on    this one's hashcode%6, but if that's occupied, increment    through successive edges looking for an open neighbor. If    none are found, look backward from predecessor to origin    hexagon, scanning their edges in the same way, until an     open neighbor is found. it is certain to find an open one. */  unsigned my_hash = *(unsigned*)utarray_eltptr(hashv,pos);  for (p = pos-1; p >= 0; p--) { // hunt through predecessor chain    for(e=0; e < 6; e++) {       // hunt through predecessor edges      unsigned bond_edge = (my_hash + e) % EDGES;      fprintf(stderr," +trying %d/%d/n",p,bond_edge);      if (available(p,bond_edge,xv,yv,&x,&y)) goto done;      fprintf(stderr," -taken, edge scanning/n");    }  }  assert(0); // not reached. it's a math thing. done:  utarray_push_back(xv, &x);  utarray_push_back(yv, &y);}

static void pop(QUEUE *stack, Cmdline *cmdline, int *idx){  Token token = stack_pop(stack);  Token *parent = stack_head(stack);  Token *p;  if (parent->var.v_type == VAR_LIST) {    if (token.symb)      return cmdline_push_var(cmdline, &token);    utarray_push_back(parent->var.vval.v_list->items, &token);    parent->end = token.end;  }  else if ((p = stack_prevprev(stack))->var.v_type == VAR_PAIR) {    Token key = stack_pop(stack);    p->var.vval.v_pair->key = key;    p->var.vval.v_pair->value = token;    p->end = token.end;    token = stack_pop(stack);    if (key.symb)      return cmdline_push_var(cmdline, &token);    Token *pt = stack_head(stack);    utarray_push_back(pt->var.vval.v_list->items, &token);  }  (*idx)++;}

void update_timer(char *key, double value){    DPRINTF("update_timer ( %s, %f )/n", key, value);    statsd_timer_t *t;    DPRINTF("HASH_FIND_STR '%s'/n", key);    HASH_FIND_STR( timers, key, t );    DPRINTF("after HASH_FIND_STR '%s'/n", key);    if (t)    {        DPRINTF("Updating old timer entry/n");        utarray_push_back(t->values, &value);        t->count++;    }    else    {        DPRINTF("Adding new timer entry/n");        t = malloc(sizeof(statsd_timer_t));        strcpy(t->key, key);        t->count = 0;        utarray_new(t->values, &timers_icd);        utarray_push_back(t->values, &value);        t->count++;        HASH_ADD_STR( timers, key, t );    }}

int parse_config(char *config_file) {  char line[100];  FILE *file;  int rc=-1;  int type,t;  char *sp,*nl,*def;  if ( (file = fopen(config_file,"r")) == NULL) {    fprintf(stderr,"can't open %s: %s/n", config_file, strerror(errno));    goto done;  }  while (fgets(line,sizeof(line),file) != NULL) {    sp = strchr(line,' '); if (!sp) continue;    nl = strchr(line,'/n'); if (nl) *nl='/0';    for(t=0; t<adim(supported_types_str); t++) {      if(!strncmp(supported_types_str[t],line,sp-line)) break;    }    if (t >= adim(supported_types_str)){      fprintf(stderr,"unknown type %s/n",line);       goto done;    }    char *id = sp+1;    sp = strchr(id,' ');    if (sp) *sp = '/0';    def = sp ? sp+1 : NULL;    utarray_push_back(output_types,&t);    utarray_push_back(output_keys,&id);    utarray_push_back(output_defaults,&def);  }  rc = 0; done:  if (file) fclose(file);  return rc;}

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);}

/* Add a cvar to an existing or new category * IN: cat_name, name of the category * IN: cvar_index, index of the cvar as defined by MPI_T_cvar_handle_alloc() * If cat_name is NULL or a empty string, nothing happpens. */int MPIR_T_cat_add_cvar(const char *cat_name, int cvar_index){    int mpi_errno = MPI_SUCCESS;    name2index_hash_t *hash_entry;    cat_table_entry_t *cat;    /* NULL or empty string are allowed */    if (cat_name == NULL || *cat_name == '/0')        goto fn_exit;    HASH_FIND_STR(cat_hash, cat_name, hash_entry);    if (hash_entry != NULL) {        /* Found it, i.e., category already exists */        int cat_idx = hash_entry->idx;        cat = (cat_table_entry_t *)utarray_eltptr(cat_table, cat_idx);        /* FIXME: Is it worth checking duplicated vars? Probably not */        utarray_push_back(cat->cvar_indices, &cvar_index);    } else {        /* Not found, so create a new category */        cat = MPIR_T_cat_create(cat_name);        utarray_push_back(cat->cvar_indices, &cvar_index);        /* Notify categories have been changed */        cat_stamp++;    }fn_exit:    return mpi_errno;fn_fail:    goto fn_exit;}

void update_timer( char *key, double value ) {  syslog(LOG_DEBUG, "update_timer ( %s, %f )/n", key, value);  statsd_timer_t *t;  syslog(LOG_DEBUG, "HASH_FIND_STR '%s'/n", key);  HASH_FIND_STR( timers, key, t );  syslog(LOG_DEBUG, "after HASH_FIND_STR '%s'/n", key);  if (t) {    syslog(LOG_DEBUG, "Updating old timer entry");    wait_for_timers_lock();    utarray_push_back(t->values, &value);    t->count++;    remove_timers_lock();  } else {    syslog(LOG_DEBUG, "Adding new timer entry");    t = malloc(sizeof(statsd_timer_t));    strcpy(t->key, key);    t->count = 0;    utarray_new(t->values, &timers_icd);    utarray_push_back(t->values, &value);    t->count++;    wait_for_timers_lock();    HASH_ADD_STR( timers, key, t );    remove_timers_lock();  }}

int main() {  UT_array *nums;  long l, *p;  UT_icd long_icd = {sizeof(long), NULL, NULL, NULL };  utarray_new(nums, &long_icd);  l=1; utarray_push_back(nums, &l);  l=2; utarray_push_back(nums, &l);  p=NULL;  while( (p=(long*)utarray_next(nums,p)) != NULL ) printf("%ld/n", *p);  utarray_free(nums);  return 0;}

/* Connect basic blocks with a directed edge.  */static edgelink_blocks (struct control_flow_graph *cfg, basic_block src, basic_block dest){  edge new_edge = (edge) malloc (sizeof (struct edge_def));  memset (new_edge, 0, sizeof (struct edge_def));  new_edge->src = src;  new_edge->dest = dest;  /* Add an edge to the source basic block.  */  utarray_push_back (src->succs, &new_edge);  /* Add an edge to the destination basic block.  */  utarray_push_back (dest->preds, &new_edge);  /* Add an edge to a list with all edges for CFG of current function.  */  utarray_push_back (cfg->edge_list, &new_edge);  return new_edge;}

/* This function copies the tree present in shared_region into the my_tree data structure for rank. * Doesn't perform any direct allocation, but utarray_new is called to allocate space for children * in my_tree. * */void MPIDI_SHM_copy_tree(int *shared_region, int num_ranks, int rank,                         MPIR_Treealgo_tree_t * my_tree, int *topotree_fail){    int c;    int *parent_ptr = shared_region;    int *child_ctr = &shared_region[num_ranks];    int *children = &shared_region[num_ranks + num_ranks + 1];    int parent = parent_ptr[rank];    int num_children = child_ctr[rank + 1] - child_ctr[rank];    int *my_children = &children[child_ctr[rank]];    my_tree->parent = parent;    my_tree->num_children = 0;    my_tree->rank = rank;    my_tree->nranks = num_ranks;    utarray_new(my_tree->children, &ut_int_icd, MPL_MEM_COLL);    utarray_reserve(my_tree->children, num_children, MPL_MEM_COLL);    char str[1024], tmp[128];    sprintf(str, "----**Rank %d, Parent, %d, Child(%d)[", rank, parent, num_children);    for (c = 0; c < num_children; ++c) {        utarray_push_back(my_tree->children, &my_children[c], MPL_MEM_COLL);        if (my_children[c] == 0) {            *topotree_fail = 1;        }        sprintf(tmp, "%d, ", my_children[c]);        strcat(str, tmp);        my_tree->num_children++;    }    if (MPIDI_SHM_TOPOTREE_DEBUG)        fprintf(stderr, "%s]/n", str);}

/* called from cdmgr.c * * for each assert of a udipredicate * to pass info to user structure */intYap_new_udi_clause(PredEntry *p, yamop *cl, Term t){	int i;	UdiPArg parg;	UdiInfo info;	YAP_Int index;	/* try to find our structure */	HASH_FIND_UdiInfo(UdiControlBlocks,p,info);	if (!info)		return FALSE;	/* insert into clauselist */	utarray_push_back(info->clauselist, &cl);	for (i = 0; i < utarray_len(info->args) ; i++) {		parg = (UdiPArg) utarray_eltptr(info->args,i);		index = (YAP_Int) utarray_len(info->clauselist);		parg->idxstr = parg->control->insert(parg->idxstr, t,											 parg->arg,											 (void *) index);	}	return TRUE;}

/** * Load uint16 array. * @param[in] option Configuration option. * @param[in,out] array Resulting array. * @return <0 - error. 0 - success. >0 - not found. */static int zcfg_load_uint16_array(const config_setting_t *option, UT_array *array){    utarray_init(array, &ut_uint16_icd);    if (!option) {        return 1;    }    if (CONFIG_TYPE_ARRAY != option->type) {        return -1;    }    int count = config_setting_length(option);    for (int i = 0; i < count; i++) {        int item = config_setting_get_int_elem(option, i);        if ((item < 0) || (item > UINT16_MAX)) {            ZLOG(LOG_ERR, "config:%s:%s: invalid port: %d", option->parent->name, option->name, item);            utarray_done(array);            return -1;        }        uint16_t port = (uint16_t) item;        utarray_push_back(array, &port);    }    if (utarray_len(array)) {        utarray_sort(array, uint16_cmp);    }    return 0;}

static voidfxaddon_load_numbered_entries(UT_array *ret, FcitxDesktopGroup *grp,                              const char *prefix, boolean stop_at_empty){    utarray_init(ret, fcitx_ptr_icd);    size_t prefix_len = strlen(prefix);    char *buff = malloc(prefix_len + FCITX_INT_LEN + 1);    memcpy(buff, prefix, prefix_len);    char *num_start = buff + prefix_len;    int i;    FcitxDesktopEntry *tmp_ety;    for (i = 0;;i++) {        sprintf(num_start, "%d", i);        tmp_ety = fcitx_desktop_group_find_entry(grp, buff);        if (!tmp_ety)            break;        if (!(tmp_ety->value && *tmp_ety->value)) {            if (stop_at_empty) {                break;            } else {                continue;            }        }        utarray_push_back(ret, &tmp_ety->value);    }    free(buff);}

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);}

void postorderRecursive(struct TreeNode* node, UT_array* v) {    if (node != NULL) {        postorderRecursive(node->left, v);        postorderRecursive(node->right, v);        utarray_push_back(v, &node->val);    }}

static TSK_WALK_RET_ENUMfind_file_act(TSK_FS_FILE * fs_file, const char *a_path, void *ptr){    char* filename= NULL;    int path_len = 0;    MBA_FFIND_DATA *data = (MBA_FFIND_DATA *) ptr;    /* We found it! */    if (fs_file->name->meta_addr == data->inode) {        data->found = 1;        path_len = strlen(a_path)+strlen(fs_file->name->name)+3;        filename = (char*)malloc(path_len);        if(filename==NULL)        {            printf("Can not allocate memory!/n");            return TSK_WALK_CONT;        }        snprintf(filename, path_len-1, "/%s%s", a_path, fs_file->name->name);        utarray_push_back(data->filenames, &filename);        if (!(data->flags & TSK_FS_FFIND_ALL)) {            return TSK_WALK_STOP;        }    }    return TSK_WALK_CONT;}

int main(int argc, char *argv[]) {  char *prog = argv[0];  int opt, rc=-1;  hex_t h;  utarray_new(cfg.hexv, &hex_icd);  while ( (opt = getopt(argc, argv, "v+i:o:h")) != -1) {    switch (opt) {      case 'v': cfg.verbose++; break;      case 'i': cfg.infile = strdup(optarg); break;      case 'o': cfg.outfile = strdup(optarg); break;      case 'h': default: usage(prog); break;    }  }  if (!cfg.outfile || !cfg.infile) usage(prog);  /* read input file */  tpl_node *tn = tpl_map("A(sii)", &h.id, &h.x, &h.y);  if (tpl_load(tn, TPL_FILE, cfg.infile)) goto done;  while(tpl_unpack(tn,1) > 0) utarray_push_back(cfg.hexv, &h);  tpl_free(tn);  find_bounds();  draw_image();  rc = 0; done:  utarray_free(cfg.hexv);  return rc;}

void hook_add_intl(int id, Plugin *host, Plugin *caller, hook_cb fn, int ev){  log_msg("HOOK", "ADD_INTL");  EventHandler *evh = get_event(ev);  Hook hook = { id, HK_INTL, NULL, caller, host, NULL, .data.fn = fn };  utarray_push_back(evh->hooks, &hook);}static void hook_rm_container(UT_array *ary, Plugin *host, Plugin *caller){  for (int i = 0; i < utarray_len(ary); i++) {    Hook *it = (Hook*)utarray_eltptr(ary, i);    if (it->host == host && it->caller == caller) {      log_err("HOOK", "RM_INTL");      utarray_erase(ary, i, 1);    }  }}void hook_rm_intl(Plugin *host, Plugin *caller, hook_cb fn, int ev){  log_msg("HOOK", "RM_INTL");  EventHandler *evh = get_event(ev);  if (!evh)    return;  hook_rm_container(evh->hooks, host, caller);}

FCITX_EXPORT_APIvoid FcitxUIRegisterStatus(    struct _FcitxInstance* instance,    void* arg,    const char* name,    const char* shortDesc,    const char* longDesc,    void (*toggleStatus)(void *arg),    boolean(*getStatus)(void *arg)){    FcitxUIStatus status;    memset(&status, 0 , sizeof(FcitxUIStatus));    status.name = strdup(name);    status.shortDescription = strdup(shortDesc);    status.longDescription = strdup(longDesc);    status.getCurrentStatus = getStatus;    status.toggleStatus = toggleStatus;    status.arg = arg;        status.visible = true;    UT_array* uistats = &instance->uistats;    utarray_push_back(uistats, &status);}

FCITX_EXPORT_APIvoid FcitxUIRegisterComplexStatus(    struct _FcitxInstance* instance,    void* arg,    const char* name,    const char* shortDesc,    const char* longDesc,    void (*toggleStatus)(void *arg),    const char*(*getIconName)(void *arg)){    FcitxUIComplexStatus compstatus;    memset(&compstatus, 0 , sizeof(FcitxUIComplexStatus));    compstatus.name = strdup(name);    compstatus.shortDescription = strdup(shortDesc);    compstatus.longDescription = strdup(longDesc);    compstatus.getIconName = getIconName;    compstatus.toggleStatus = toggleStatus;    compstatus.arg = arg;    compstatus.visible = true;    UT_array* uicompstats = &instance->uicompstats;    utarray_push_back(uicompstats, &compstatus);    if (UI_FUNC_IS_VALID(RegisterComplexStatus))        instance->ui->ui->RegisterComplexStatus(instance->ui->addonInstance, (FcitxUIComplexStatus*) utarray_back(uicompstats));    if (UI_FUNC_IS_VALID_FALLBACK(RegisterComplexStatus))        instance->uifallback->ui->RegisterComplexStatus(instance->uifallback->addonInstance, (FcitxUIComplexStatus*) utarray_back(uicompstats));}

UT_array* memfrs_scan_virmem( CPUState *cpu, uint64_t start_addr, uint64_t end_addr, const char* pattern, int length ) {    uint64_t i;    if(start_addr >= end_addr) {        printf("end_addr is not less than start_addr/n");        return NULL;    }    uint8_t* buf = (uint8_t*)malloc(length);    UT_array *match_addr;    memset(buf, 0, length);    if(buf == NULL) {        printf("Cannot allocate memory for do_show_memory_taint_map()/n");        return NULL;    }    utarray_new( match_addr, &adr_icd);    printf("Scan for pattern %s/n", pattern);    for(i = start_addr; i < end_addr-length+1; i++)    {        cpu_memory_rw_debug(cpu, i, buf, length, 0);        if(memcmp(buf, pattern, length)==0)        {            printf("pattern found %lx/n", i);            utarray_push_back(match_addr, &i);        }    }    return match_addr;}

/* * Here we initialize the arguments indexing */YAP_Intp_udi_args_init(Term spec, int arity, UdiInfo blk){	int i;	Term arg;	Atom idxtype;	UdiControlBlock *cb;	struct udi_p_args p_arg;	for (i = 1; i <= arity; i++) {		arg = ArgOfTerm(i,spec);		if (IsAtomTerm(arg)) {			idxtype = AtomOfTerm(arg);			if (idxtype == AtomMinus) //skip this argument				continue;			p_arg.control = NULL;			cb = NULL;			while ((cb = (UdiControlBlock *) utarray_next(indexing_structures, cb))) {				if (idxtype == (*cb)->decl){					p_arg.arg = i;					p_arg.control = *cb;					p_arg.idxstr = (*cb)->init(spec, i, arity);					utarray_push_back(blk->args, &p_arg);				}			}			if (p_arg.control == NULL){ /* not "-" and not found */				fprintf(stderr, "Invalid Spec (%s)/n", AtomName(idxtype));				return FALSE;			}		}	}	return TRUE;}

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;}

/*******************************************************************UT_array* memfrs_scan_phymem( uint64_t start_addr, uint64_t end_addr, const char* pattern )Scan for specific pattern in the VM's physical memoryINPUT:    uint64_t start_addr,  The start address          uint64_t end_addr,    the end address          const char* pattern   pattern to search, support only ascii stringOUTPUT:   UT_array*,            An UT_array that contains the address of found pattern*******************************************************************/UT_array* memfrs_scan_phymem( uint64_t start_addr, uint64_t end_addr, const char* pattern , int length ) {    uint64_t i;    UT_array *match_addr;    if(start_addr >= end_addr) {        printf("end_addr is not less than start_addr/n");        return NULL;    }    uint8_t* buf = (uint8_t*)malloc(length);    if(buf == NULL) {        printf("Cannot allocate memory for memfrs_scan_phymem()/n");        return NULL;    }    utarray_new( match_addr, &adr_icd);    printf("Scan for pattern %s/n", pattern);    for(i = start_addr; i < end_addr-length+1; i++)    {        cpu_physical_memory_read(i, buf, length);        if(memcmp(buf, pattern, length)==0)        {            printf("pattern found %lx/n", i);            utarray_push_back(match_addr, &i);        }    }    return match_addr;}

void LoadAutoEng(FcitxAutoEngState* autoEngState){    FILE    *fp;    char    *buf = NULL;    size_t   length = 0;    LoadAutoEngConfig(&autoEngState->config);    fp = FcitxXDGGetFileWithPrefix("data", "AutoEng.dat", "r", NULL);    if (!fp)        return;    utarray_new(autoEngState->autoEng, &autoeng_icd);    AUTO_ENG autoeng;    while (getline(&buf, &length, fp) != -1) {        char* line = fcitx_utils_trim(buf);        if (strlen(line) > MAX_AUTO_TO_ENG)            FcitxLog(WARNING, _("Too long item for AutoEng"));        strncpy(autoeng.str, line, MAX_AUTO_TO_ENG);        free(line);        autoeng.str[MAX_AUTO_TO_ENG] = '/0';        utarray_push_back(autoEngState->autoEng, &autoeng);    }    free(buf);    fclose(fp);}

/*-----------------------------------------------------------------------------*   process a file*----------------------------------------------------------------------------*/static void process_file( char *filename ){	char *line;    strip( filename );    switch ( filename[0] )    {    case '-':		/* Illegal source file name */        error_illegal_src_filename( filename );        break;    case '/0':		/* no file */        break;	case '@':		/* file list */		filename++;						/* point to after '@' */		strip( filename );		/* loop on file to read each line and recurse */		src_push();		{			if (src_open(filename, NULL))			{				while ((line = src_getline()) != NULL)					process_file(line);			}		}		src_pop();		break;    default:		utarray_push_back(opts.files, &filename);    }}

void XimPendingCall(FcitxXimFrontend* xim, XimCallType type, XPointer ptr){    XimQueue item;    item.type = type;    item.ptr = ptr;    utarray_push_back(xim->queue, &item);}

/* accept a new client connection to the listening socket */int accept_client() {  int fd, fl;  struct sockaddr_in in;  socklen_t sz = sizeof(in);  fd = accept(cfg.fd,(struct sockaddr*)&in, &sz);  if (fd == -1) {    if (errno == EWOULDBLOCK || errno == EAGAIN) goto done;    fprintf(stderr,"accept: %s/n", strerror(errno)); goto done;  }  if (cfg.verbose && (sizeof(in)==sz)) {    fprintf(stderr,"connection fd %d from %s:%d/n", fd,    inet_ntoa(in.sin_addr), (int)ntohs(in.sin_port));  }  /* request signal whenever input from client is available */  fl = fcntl(fd, F_GETFL);  fl |= O_ASYNC|O_NONBLOCK;        /* want a signal on fd ready */  fcntl(fd, F_SETFL, fl);  fcntl(fd, F_SETSIG, SIGIO);  fcntl(fd, F_SETOWN, cfg.pid);    /* send it to our pid */ done:  if (fd != -1) utarray_push_back(cfg.fds,&fd);  return fd;}

/*-----------------------------------------------------------------------------*   String pool for the current statement*----------------------------------------------------------------------------*/static char *token_strings_add(ParseCtx *ctx, char *str){	if (!str)		/* NULL string */		return NULL;	utarray_push_back(ctx->token_strings, &str);	return *((char **)utarray_back(ctx->token_strings));}

static int lines_add(UT_array *lines, const line_t *line){    int i;    i = lines_find(lines, line);    if (i) return i;    utarray_push_back(lines, line);    return lines_find(lines, line);}