Example #1
0
/*
 * del_arginfo
 *   ( called by _free_args() )
 *
 */
void del_arginfo(APTR data)
{

    struct arginfo *arg = (struct arginfo *) data;

    if (arg)
    {

        /* type dependent cleanup */
        if (arg->ai_type == ARG_ENUM)
            ufree(arg->ai_misc1.ai_enum);

        /* cleanup entities */
        ufree(arg->ai_id);
        ufree(arg->ai_help);
        arg->ai_type = 0;
        arg->ai_dest = NULL;
        arg->ai_func = NULL;

        /* cleanup whole structure */
        ufree(arg);

    }

}
Example #2
0
static void
hash_ctx_destroy_cb(struct hash_ctx *ctx)
{
	ufree(ctx->name);
	ufree(ctx->ctx);
	ufree(ctx);
}
Example #3
0
VOID del_estr(EXPSTR * es)
{
#if DEBUG_UGLY_EXPSTR
    if (es) {
        if (es->es_data) {
#if DEBUG_UGLY_EXPSTR == 2
            STRARR s[17];
            strncpy(s, es->es_data, 17);
            s[16] = 0;
            D(fprintf(stderr, DEXP "del_estr(%p,`%s')\n", es, s));
            umem_wallcheck("del_estr()");
#endif
        } else {
            D(fprintf(stderr, DEXP "attempt to free null-data-estr\n"));
        }
    } else {
#if DEBUG_UGLY_EXPSTR == 2
        D(fprintf(stderr, DEXP "attempt to free null-estr\n"));
#endif
    }
#endif

    if (es) {

        ufree(es->es_data);
        es->es_len = 0;
        es->es_size = 0;
        es->es_step = 0;
        ufree(es);

    }
}
Example #4
0
void lpp_load_sol(LPP *lpp, LPX *prob)
{     int i, j, ref, stat;
      double prim, dual;
      insist(lpp->m == lpx_get_num_rows(prob));
      insist(lpp->n == lpx_get_num_cols(prob));
      insist(lpp->orig_dir == lpx_get_obj_dir(prob));
      insist(lpx_get_status(prob) != LPX_UNDEF);
      for (i = 1; i <= lpp->m; i++)
      {  lpx_get_row_info(prob, i, &stat, &prim, &dual);
         ref = lpp->row_ref[i];
         insist(1 <= ref && ref <= lpp->nrows);
         insist(lpp->row_stat[ref] == 0);
         lpp->row_stat[ref] = stat;
         lpp->row_prim[ref] = prim;
         lpp->row_dual[ref] =
            (lpp->orig_dir == LPX_MIN ? + dual : - dual);
      }
      for (j = 1; j <= lpp->n; j++)
      {  lpx_get_col_info(prob, j, &stat, &prim, &dual);
         ref = lpp->col_ref[j];
         insist(1 <= ref && ref <= lpp->ncols);
         insist(lpp->col_stat[ref] == 0);
         lpp->col_stat[ref] = stat;
         lpp->col_prim[ref] = prim;
         lpp->col_dual[ref] =
            (lpp->orig_dir == LPX_MIN ? + dual : - dual);
      }
      ufree(lpp->row_ref), lpp->row_ref = NULL;
      ufree(lpp->col_ref), lpp->col_ref = NULL;
      return;
}
Example #5
0
void ds_msg_free_handle(ds_msg_handle_t *handle)

{

  _check_init(handle);

  if (handle->parts) {
    int i;
    for (i = 0; i < handle->hdr.nParts; i++) {
      if (handle->parts[i].buf) {
	ufree(handle->parts[i].buf);
	handle->parts[i].buf = NULL;
	handle->parts[i].n_buf_alloc = 0;
      }
    }
    ufree(handle->parts);
    handle->parts = NULL;
    handle->n_parts_alloc = 0;
  }
  
  if (handle->assembled_msg) {
    ufree (handle->assembled_msg);
    handle->assembled_msg = NULL;
    handle->n_assembled_alloc = 0;
  }

  handle->init_flag = 0;

}
Example #6
0
static void new_coef(struct dsa *dsa, int i, int j, double aij)
{   /* add new element to the transformed constraint matrix */
    insist(1 <= i && i <= dsa->m);
    insist(1 <= j && j <= dsa->n);
    insist(aij != 0.0);
    if (dsa->ne == dsa->size)
    {   int *ia = dsa->ia;
        int *ja = dsa->ja;
        double *ar = dsa->ar;
        dsa->size += dsa->size;
        dsa->ia = ucalloc(1+dsa->size, sizeof(int));
        memcpy(&dsa->ia[1], &ia[1], dsa->ne * sizeof(int));
        ufree(ia);
        dsa->ja = ucalloc(1+dsa->size, sizeof(int));
        memcpy(&dsa->ja[1], &ja[1], dsa->ne * sizeof(int));
        ufree(ja);
        dsa->ar = ucalloc(1+dsa->size, sizeof(double));
        memcpy(&dsa->ar[1], &ar[1], dsa->ne * sizeof(double));
        ufree(ar);
    }
    insist(dsa->ne < dsa->size);
    dsa->ne++;
    dsa->ia[dsa->ne] = i;
    dsa->ja[dsa->ne] = j;
    dsa->ar[dsa->ne] = aij;
    return;
}
Example #7
0
void
id_item_free(id_item_t *item)
{
    item->destructor(item);

    ufree(item->name);
    ufree(item);
}
Example #8
0
/*
 * Parse the string @a maskStr containing a hex number (with or without
 * leading "0x") and set nodemask accordingly.
 *
 * If the sting is not a valid hex number, each bit in nodemask becomes set.
 */
static void parseNUMAmask(struct bitmask *nodemask, char *maskStr, int32_t rank)
{
    char *mask, *curchar, *endptr;
    size_t len;
    uint32_t curbit;
    uint16_t i, j, digit;

    mask = maskStr;

    if (strncmp(maskStr, "0x", 2) == 0) {
	/* skip "0x", treat always as hex */
	mask += 2;
    }

    mask = ustrdup(mask); /* gets destroyed */

    len = strlen(mask);
    curchar = mask + (len - 1);
    curbit = 0;
    for (i = len; i > 0; i--) {
	digit = strtol(curchar, &endptr, 16);
	if (*endptr != '\0') {
	    mlog("%s: error parsing memory mask '%s'\n", __func__, maskStr);
	    goto error;
	}

	for (j = 0; j < 4; j++) {
	    if (digit & (1 << j)) {
		if ((long int)(curbit + j) > numa_max_node()) {
		    mlog("%s: invalid memory mask entry '%s' for rank %d\n",
			    __func__, maskStr, rank);
		    fprintf(stderr, "Invalid memory mask entry '%s' for rank"
			    " %d\n", maskStr, rank);
		    goto error;
		}
		if (numa_bitmask_isbitset(numa_get_mems_allowed(),
			    curbit + j)) {
		    numa_bitmask_setbit(nodemask, curbit + j);
		} else {
		    mlog("%s: setting bit %u in memory mask not allowed in"
			    " rank %d\n", __func__, curbit + j, rank);
		    fprintf(stderr, "Not allowed to set bit %u in memory mask"
			    " of rank %d\n", curbit + j, rank);
		}
	    }
	}
	curbit += 4;
	*curchar = '\0';
	curchar--;
    }

    ufree(mask);
    return;

error:
    ufree(mask);
    numa_bitmask_setall(nodemask);
}
Example #9
0
void CClp_free_warmstart(CClp_warmstart **warm)
{     /* FREES the memory used by warm. */
      if (*warm != NULL)
      {  if ((*warm)->cstat != NULL)
            ufree((*warm)->cstat), (*warm)->cstat = NULL;
         if ((*warm)->rstat != NULL)
            ufree((*warm)->rstat), (*warm)->rstat = NULL;
         ufree((*warm)), (*warm) = NULL;
      }
      return;
}
Example #10
0
void CClp_free_info(CClp_info **info)
{     /* FREES the memory used by info. */
      if ((*info) != NULL)
      {  if ((*info)->cstat != NULL)
            ufree((*info)->cstat), (*info)->cstat = NULL;
         if ((*info)->rstat != NULL)
            ufree((*info)->rstat), (*info)->rstat = NULL;
         ufree((*info)), (*info) = NULL;
      }
      return;
}
Example #11
0
/* insert an aligned entry into the table and return non-zero on success */
int __umalloc_aligned_insert(struct mdesc *mdp, void *exact, void *aligned) {
    umalloc_heap_t *md = (umalloc_heap_t *)mdp;

    /* fetch a list cell to use */
    struct alignlist *newl = mdp->aligned_freelist;
    if (newl) mdp->aligned_freelist = newl->next;
    else if ((newl = (struct alignlist *) 
             umalloc(md, sizeof(struct alignlist))) == NULL) return 0;
    newl->aligned = aligned;
    newl->exact = exact;

    if (mdp->aligned_block_table == NULL) { /* first call - create table */
      mdp->aligned_block_table = ucalloc(md, INITIAL_TABLE_SZ, sizeof(struct alignlist*));
      if (mdp->aligned_block_table == NULL) {
        ufree(md, newl);
        return 0;
      }
      mdp->aligned_block_tablecnt = 0;
      mdp->aligned_block_tablesz = INITIAL_TABLE_SZ;
    } else if (mdp->aligned_block_tablecnt >= mdp->aligned_block_tablesz) { /* rehash */
      uintptr_t newtablesz = mdp->aligned_block_tablesz*2 + 1;
      uintptr_t i;
      struct alignlist **newtable = ucalloc(md, newtablesz, sizeof(struct alignlist*));
      if (newtable == NULL) {
        ufree(md, newl);
        return 0;
      }
      for (i=0; i < mdp->aligned_block_tablesz; i++) {
        struct alignlist *cur = mdp->aligned_block_table[i];
        while (cur) {
          struct alignlist *next = cur->next;
          uintptr_t key = ((uintptr_t)(cur->aligned))%newtablesz;
          cur->next = newtable[key];
          newtable[key] = cur;
          cur = next;
        }
      }
      { void *oldtable = mdp->aligned_block_table;
        mdp->aligned_block_table = newtable;
        mdp->aligned_block_tablesz = newtablesz;
        ufree(md, oldtable);
      }
    }

    /* insert */
    { uintptr_t key = ((uintptr_t)aligned)%mdp->aligned_block_tablesz;
      newl->next = mdp->aligned_block_table[key];
      mdp->aligned_block_table[key] = newl;
      mdp->aligned_block_tablecnt++;
    }
    return 1; 
}
Example #12
0
File: hscprc.c Project: mbethke/hsc
/*
 * del_hscprc
 *
 * Remove HSC process and all its resources
 */
void del_hscprc(HSCPRC *hp)
{
    if (hp) {
        /* remove list */
        del_hsctree(hp->defstyle);
        del_dllist(hp->defent);
        del_hsctree(hp->deftag);
        del_dllist(hp->defattr);
        del_hsctree(hp->deflazy);
        del_dllist(hp->container_stack);
        del_dllist(hp->content_stack);
        del_dllist(hp->inpf_stack);
        del_dllist(hp->idrefs);
        del_dllist(hp->select_stack);
        del_dllist(hp->tag_styles);
        del_strlist(hp->include_dirs);

        /* remove precompiled regular expressions */
        hscregfreeall(hp->re_uri);

        /* remove strings */
        del_estr(hp->destdir);
        del_estr(hp->reldir);
        del_estr(hp->iconbase);
        del_estr(hp->server_dir);
        del_estr(hp->if_stack);
        del_estr(hp->tag_name_str);
        del_estr(hp->tag_attr_str);
        del_estr(hp->tag_close_str);
        del_estr(hp->tmpstr);
        del_estr(hp->curr_msg);
        del_estr(hp->curr_ref);
        del_estr(hp->whtspc);

        ufreestr(hp->filename_document);
        ufreestr(hp->strip_tags);

        ufree(hp->image_buffer);

        /* remove project-data */
        del_project(hp->project);

        /* close input files */
        infclose(hp->inpf);

        /* remove message arrays */
        ufree(hp->msg_ignore);
        ufree(hp->msg_class);

        ufree(hp);
    }
}
Example #13
0
static void
lex_prev_free(void)
{
	switch(lex_prev.token) {
	case TOKEN_ID:
		ufree(lex_prev.id);
		break;
	case TOKEN_STRING:
		ufree(lex_prev.string);
		break;
	default:
		break;	
	}
}
Example #14
0
/*---------------------------------------------------------------------------*/
int xio_free(struct xio_buf **buf)
{
	struct xio_mr		*tmr = (*buf)->mr;
	int			retval = 0;

	if ((*buf)->addr)
		ufree((*buf)->addr);

	retval = xio_dereg_mr(&tmr);

	ufree(*buf);
	*buf = NULL;

	return retval;
}
Example #15
0
/* 
 * del_dlnode()
 *
 * remove entry from double linked list
 *
 */
void del_dlnode(struct dllist *list, struct dlnode *node)
{

    if (list && node)
    {                           /* list & node node defined? */

        void (*dd) (APTR) = list->del_data;

        if (node->data)         /* Y-> call destructor */
            if (dd)
                (*dd) (node->data);

        if (node->prev)         /*     remove node from list */
            node->prev->next = node->next;
        else
            list->first = node->next;
        list->entry_num--;

        if (node->next)
            node->next->prev = node->prev;
        else
            list->last = node->prev;

        node->prev = NULL;      /*     clear node */
        node->next = NULL;
        node->data = NULL;

        ufree(node);            /*     free node */
    }
}
Example #16
0
int task_main(void* args) {
    int i;
    int eid;
    int size;
    int rts;
    char* ubuf;

    if (argc < 4) {
        printf("usage: thr_sender <connect-to> <msg-size> <roundtrips>\n");
        return 0;
    }

    size = atoi(argv[2]);
    rts = atoi(argv[3]);
    BUG_ON((eid = sp_endpoint(SP_REQREP, SP_REQ)) < 0);
    BUG_ON(sp_connect(eid, argv[1]) < 0);

    BUG_ON(sp_send(eid, ualloc(size)) != 0);

    for (i = 0; i < rts; i++) {
        BUG_ON(sp_send(eid, ualloc(size)) != 0);
    }

    BUG_ON(sp_recv(eid, &ubuf) != 0);
    ufree(ubuf);

    sp_close(eid);
    return 0;
}
Example #17
0
/*
 * get_mid_estr
 *
 * get a part from a expstr; compare BASIC's "MID$()"
 *
 * params: dest...destination expstr where to store result part
 *         src....source expstr where to get part from
 *         from...position of char where to begin part (0=first char)
 *         num....number of chars to get
 * result: TRUE and result in dest if ok; else FALSE is returned an
 *         dest is left untouched
 *
 * NOTE: it is possible to use the source-exstr as destination-expstr,
 *       because the result is copied to a temp. expstr before
 *       ( example: get_mid_estr( hugo, hugo, 3, 4 ); )
 */
BOOL get_mid_estr(EXPSTR * dest, EXPSTR * src, size_t from, size_t num)
{
    BOOL ok = FALSE;
    EXPSTR *tmp = init_estr(dest->es_step);

    if (tmp) {

        STRPTR old_data = tmp->es_data;

        /* check size */
        if (from >= src->es_len)
            from = src->es_len - 1;
        if (from + num >= src->es_len)
            num = src->es_len - from - 1;

        /* set new mem for tmp */
        ok = set_estr_mem(tmp, modadj(num + 1, tmp->es_step));

        if (ok) {

            /* copy data */
            strncpy(estr2str(tmp), estr2str(src) + from, num);
            tmp->es_data[num] = 0;
            tmp->es_len = num + 1;
            ufree(old_data);

            ok = estrcpy(dest, tmp);

        }
        del_estr(tmp);

    }
    return (ok);
}
Example #18
0
void
id_item_default_release(id_item_t *item)
{
    assert(item != NULL);

    switch (item->type) {
    case ID_VAR:
        if (item->var != NULL) {
            var_clear(item->var);
            ufree(item->var);
            item->var = NULL;
        }
        break;
    case ID_ARR:
        if (item->arr != NULL) {
            arr_free(item->arr);
            item->arr = NULL;
        }
        break;
    case ID_UNKNOWN:
    default:
        error(1, "unknown id type\n");
        break;
    }
}
Example #19
0
/*
**-------------------------------------
** append char/string to expstr
**-------------------------------------
*/
BOOL app_estrch( EXPSTR *es, int ch )
{
    BOOL   ok = TRUE;
    STRPTR s;

    if ( es->es_len >= es->es_size ) {           /* enough mem left? */

        STRPTR old_data = es->es_data;           /* N->remeber old data ptr */

        if ( set_estr_mem(es,
                 es->es_size + es->es_step ) )
        {                                        /*    set new mem sucessful? */

            strcpy( es->es_data,                 /*    Y->copy old data */
                    old_data );
            ufree( old_data );                   /*       release old data */

        } else {
                                                 /*    N->return error */
            ok = FALSE;
        }
    }

    if ( ok ) {
        s = es->es_data;
        s[es->es_len-1] = ch;          /* append new char to expstr */
        s[es->es_len]   = 0;
        es->es_len++;                  /* incr. expstr length */
    }

    return( ok );
}
Example #20
0
/*
 * del_hsctag
 */
void del_hsctag(APTR data)
{
    HSCTAG *tag = (HSCTAG *) data;

    /* release mem */
    ufreestr(tag->name);
    ufreestr(tag->name);
    del_estr(tag->op_text);
    del_estr(tag->cl_text);
    ufreestr(tag->mbi);
    ufreestr(tag->naw);
    del_dllist(tag->attr);
    del_infilepos(tag->start_fpos);
    del_infilepos(tag->end_fpos);

    /* clear values */
    tag->option = 0;
    tag->op_text = NULL;
    tag->cl_text = NULL;
    tag->attr = NULL;
    tag->uri_size = NULL;
    tag->uri_stripext = NULL;

    ufree(tag);
}
Example #21
0
BOOL ugly_dbg_app_estrch(EXPSTR * es, int ch, STRPTR file, ULONG line)
{
    BOOL ok = TRUE;

    if (!es) {
        es_null("app_estrch", file, line);
        ok = FALSE;
    } else if (es->es_len >= es->es_size) {     /* enough mem left? */

        STRPTR old_data = es->es_data;  /* N->remeber old data ptr */

        if (ugly_dbg_set_estr_mem(es,
                                  es->es_size + es->es_step, file, line)) {
            /*    set new mem sucessfully? */

            strcpy(es->es_data, /*    Y->copy old data */
                   old_data);
            ufree(old_data);    /*       release old data */
        } else {                /*    N->return error */
            ok = FALSE;
        }
    }
    if (ok) {

        STRPTR s;
        s = es->es_data;
        s[es->es_len - 1] = ch; /* append new char to expstr */
        s[es->es_len] = 0;
        es->es_len++;           /* incr. expstr length */

    }
    return (ok);
}
Example #22
0
//-------------------------------------------------------------------
void conf_save() {
    static const long t=CONF_MAGICK_VALUE;
    register int i;
    int fd;
    char *buf=umalloc(sizeof(t)+CONF_NUM*(sizeof(conf_info[0].id)+sizeof(conf_info[0].size))+sizeof(conf));
    char *p=buf;

    fd = open(CONF_FILE, O_WRONLY|O_CREAT|O_TRUNC, 0777); 
    if (fd>=0){
        memcpy(p, &t, sizeof(t));
        p+=sizeof(t);
        for (i=0; i<CONF_NUM; ++i) {
            memcpy(p, &(conf_info[i].id), sizeof(conf_info[i].id));
            p+=sizeof(conf_info[i].id);
            memcpy(p, &(conf_info[i].size), sizeof(conf_info[i].size));
            p+=sizeof(conf_info[i].size);
            memcpy(p, conf_info[i].var, conf_info[i].size);
            p+=conf_info[i].size;
        }

        write(fd, buf, p-buf);
        close(fd);
    }
	ufree(buf);
}
Example #23
0
File: pixbuf.c Project: 42wim/ipxe
/**
 * Free pixel buffer
 *
 * @v refcnt		Reference count
 */
static void free_pixbuf ( struct refcnt *refcnt ) {
	struct pixel_buffer *pixbuf =
		container_of ( refcnt, struct pixel_buffer, refcnt );

	ufree ( pixbuf->data );
	free ( pixbuf );
}
Example #24
0
static void check_memory(void)
{

  param_list_t *p_list;
  int n_allocated;

  if (Nparams + 1 > Nallocated) {

    /*
     * allocate another block of space
     */

    n_allocated = Nallocated + N_ALLOCATE;

    p_list = (param_list_t *) umalloc(n_allocated * sizeof(param_list_t));

    if (Nallocated > 0) {
      memcpy(p_list, Plist, Nallocated * sizeof(param_list_t));
      ufree(Plist);
    } /* if (Nallocated > 0) */

    Plist = p_list;

    Nallocated = n_allocated;

  } /* if (Nparams + 1 > Nallocated) */

}
Example #25
0
/*
 * free_args
 *
 * free all memory allocated by _prepare_args()
 *
 * MUST be called after _set_args()
 *
 */
void free_args(struct arglist *al)
{
    if (al)
    {
        del_dllist(al->al_list);
        ufree(al);
    }
}
Example #26
0
int dispose_stack(stack* s, void (*ufree)(void*)) {
	void* data;
	while ((data = pop_stack(s)) != NULL) {
		ufree(data);
	}
	free(s);
	return 1;
}
Example #27
0
/* del_idref: remove referenced id */
VOID del_idref(APTR data)
{
    IDREF *idref = (IDREF *) data;

    ufreestr(idref->name);
    del_infilepos(idref->fpos);
    ufree(idref);
}
Example #28
0
/*
** del_tag
*/
void del_tag( APTR data )
{
    HSCTAG *tag = (HSCTAG *)data;

    ufreestr( tag->name );
    ufree( tag );

}
Example #29
0
/*
 * del_hscprc
 *
 * remove hsc process and all it's resources
 */
VOID del_hscprc(HSCPRC * hp)
{
    if (hp)
    {
        /* remove list */
        del_dllist(hp->defent);
        del_dllist(hp->deftag);
        del_dllist(hp->defattr);
        del_dllist(hp->container_stack);
        del_dllist(hp->content_stack);
        del_dllist(hp->inpf_stack);
        del_dllist(hp->idrefs);
        del_dllist(hp->select_stack);
        del_strlist(hp->include_dirs);

        /* remove strings */
        del_estr(hp->destdir);
        del_estr(hp->reldir);
        del_estr(hp->iconbase);
        del_estr(hp->server_dir);
        del_estr(hp->if_stack);
        del_estr(hp->tag_name_str);
        del_estr(hp->tag_attr_str);
        del_estr(hp->tag_close_str);
        del_estr(hp->tmpstr);
        del_estr(hp->curr_msg);
        del_estr(hp->curr_ref);
        del_estr(hp->whtspc);

        ufreestr(hp->filename_document);
        ufreestr(hp->strip_tags);

        /* remove project-data */
        del_project(hp->project);

        /* close input files */
        infclose(hp->inpf);

        /* remove message arrays */
        ufree(hp->msg_ignore);
        ufree(hp->msg_class);

        ufree(hp);
    }
}
Example #30
0
void b_close(int fd)
{
    if (fd >= 0)
        close(fd);

    if (buf_load)
        ufree(buf_load);
    buf_load=0;
}