コード例 #1
0
ファイル: sdmap.c プロジェクト: ifzz/libsrt
sdm_t *sdm_dup(const sdm_t *src)
{
	ASSERT_RETURN_IF(!src, NULL);
	size_t nsubmaps = sdm_size(src);
	ASSERT_RETURN_IF(!nsubmaps, NULL);
	const sm_t **maps = sdm_submaps_r(src);
	ASSERT_RETURN_IF(!maps, NULL);
	ASSERT_RETURN_IF(!maps[0], NULL);
	enum eSM_Type t = (enum eSM_Type)maps[0]->f.type;
	ASSERT_RETURN_IF(t >= SM_TotalTypes, NULL);
	size_t alloc_size = sizeof(sdm_t) + sizeof(sm_t *) * (nsubmaps - 1);
	sdm_t *dm = (sdm_t *)__sd_malloc(alloc_size);
	ASSERT_RETURN_IF(!dm, NULL);
	size_t i = 0;
	for (; i < nsubmaps; i++ ) {
		if (!(dm->maps[i] = sm_dup(maps[i])))
			break; /* Allocation error */
	}
	if (i != nsubmaps) { /* Handle allocation error */
		for (; i < nsubmaps; i++ ) {
			if (dm->maps[i])
				sm_free(&dm->maps[i]);
			else
				break;
		}
		free(dm);
		dm = NULL;
	}
	return dm;
}
コード例 #2
0
ファイル: sminterf.c プロジェクト: CARV-ICS-FORTH/scoop
pset
do_sm_minimum_cover(pset_family A)
{
sm_matrix *M;
sm_row *sparse_cover;
sm_element *pe;
pset cover;
register int i, base, rownum;
register unsigned val;
register pset last, p;
M = sm_alloc();
rownum = 0;
for( p=A->data, last= p+A->count*A->wsize; p< last; p+=A->wsize) {
for( i = (p[0] & 0x03ff); i > 0; ) for( val = p[ i], base = -- i << 5; val != 0; base++, val >>= 1) if ( val & 1) {
(void) sm_insert(M, rownum, base);
}
rownum++;
}
sparse_cover = sm_minimum_cover(M, ((int *) 0), 1, 0);
sm_free(M);
cover = set_clear(((unsigned int *) malloc(sizeof(unsigned int) * ( ((A->sf_size) <= 32 ? 2 : (((((A->sf_size)-1) >> 5) + 1) + 1))))), A->sf_size);
for( pe = sparse_cover->first_col; pe != 0; pe = pe->next_col) {
(cover[((( pe->col_num) >> 5) + 1)] |= 1 << (( pe->col_num) & (32-1)));
}
sm_row_free(sparse_cover);
return cover;
}
コード例 #3
0
ファイル: nvar.c プロジェクト: kkentzo/dps.old
void nvar_free(nvar_t *nvar) {

    // free individual labels here
    int i;
    for (i=0; i<nvar->dim; i++)
	if (nvar->labels[i])
	    free(nvar->labels[i]);

    int nlabels = nvar_count_covariances(nvar);
    for (i=0; i<nlabels; i++)
	if (nvar->plabels[i])
	    free(nvar->plabels[i]);

    
    free(nvar->wsums);

    sm_free(nvar->sum_wprods);

    // free the array 
    free(nvar->labels);
    free(nvar->plabels);

    free(nvar);

}
コード例 #4
0
void iwdpm_create_bridge(iwdpm_t self) {
  sm_t sm = sm_new(4096);
  iwdp_t iwdp = iwdp_new(self->frontend);
  if (!sm || !iwdp) {
    sm_free(sm);
    return;
  }
  self->sm = sm;
  self->iwdp = iwdp;
  iwdp->subscribe = iwdpm_subscribe;
  iwdp->attach = iwdpm_attach;
  iwdp->select_port = iwdpm_select_port;
  iwdp->listen = iwdpm_listen;
  iwdp->connect = iwdpm_connect;
  iwdp->send = iwdpm_send;
  iwdp->add_fd = iwdpm_add_fd;
  iwdp->remove_fd = iwdpm_remove_fd;
  iwdp->state = self;
  iwdp->is_debug = &self->is_debug;
  sm->on_accept = iwdpm_on_accept;
  sm->on_sent = iwdpm_on_sent;
  sm->on_recv = iwdpm_on_recv;
  sm->on_close = iwdpm_on_close;
  sm->state = self;
  sm->is_debug = &self->is_debug;
}
コード例 #5
0
ファイル: bsys.c プロジェクト: pstray/bareos
void bfree(void *buf)
{
#ifdef SMARTALLOC
  sm_free(__FILE__, __LINE__, buf);
#else
  free(buf);
#endif
}
コード例 #6
0
void sm_destroy_thread_samplers() {
  StackMachine *sm;
  int i;
  
  for (i=1; i<MAXTHREAD; i++) {
    sm_free(sampler_machines[i]);
    sampler_machines[i] = NULL;
  }
}
コード例 #7
0
ファイル: im.c プロジェクト: Daksh/tuxpaint-0.9.21
/**
* Free the resources used by a character map.
*/
static void charmap_free(CHARMAP* cm)
{
  int i;

  for(i = 0; i < MAX_SECTIONS; i++) {
    sm_free(&cm->sections[i]);
  }

  memset(cm, 0, sizeof(CHARMAP));
}
コード例 #8
0
ファイル: sharedmem.c プロジェクト: ekd123/ekode
void *sm_unref (void *ptr)
{
    _ptr_to_sm (ptr)->refcount --;
    if (_ptr_to_sm (ptr)->refcount <= 0)
    {
        sm_free (ptr);
        return NULL;
    }
    return ptr;
}
コード例 #9
0
void iwdpm_free(iwdpm_t self) {
  if (self) {
    pc_free(self->pc);
    iwdp_free(self->iwdp);
    sm_free(self->sm);
    free(self->config);
    free(self->frontend);
    memset(self, 0, sizeof(struct iwdpm_struct));
    free(self);
  }
}
コード例 #10
0
ファイル: smap.c プロジェクト: ifzz/libsrt
sm_t *sm_cpy(sm_t **m, const sm_t *src)
{
	RETURN_IF(!m || !src, NULL); /* BEHAVIOR */
	size_t i;
	const enum eSM_Type t = (enum eSM_Type)src->f.type;
	size_t ss = sm_size(src),
	       src_buf_size = ST_SIZE_TO_ALLOC_SIZE(ss, sm_elem_size(t));
	if (*m) {
		if (sd_is_using_ext_buffer((const sd_t *)src))
		{	/* If using ext buffer, we'll have grow limits */
			sm_reset(*m);
			size_t oe = st_capacity(*m),
			       os = ST_SIZE_TO_ALLOC_SIZE(oe, sm_elem_size(t));
			RETURN_IF(os < src_buf_size, NULL); /* BEHAVIOR */
			*m = sm_alloc_raw(t, S_TRUE, *m, os);
		} else {
			if ((*m)->f.type == t) {
				st_reserve(m, ss);
			} else {
				sm_free(m);
				*m = NULL;
			}
		}
	}
	if (!*m)
		*m = sm_alloc(t, ss);
	RETURN_IF(!*m || st_capacity(*m) < ss, NULL); /* BEHAVIOR */
	switch (t) {
	/*
	 * Fast copy: compact structure (without strings)
	 */
	case SM_I32I32: case SM_U32U32: case SM_IntInt: case SM_IntPtr:
		memcpy(*m, src, src_buf_size);
		break;
	/*
	 * Slow map copy for types having strings as key or value:
	 */
#define case_SM_CPY_InsertLoop(SM_xy, ST, INSERTF)			\
	case SM_xy:							\
		for (i = 0; i < ss; i++) {				\
			const ST *s = (const ST *)sm_enum_r(*m, i);	\
			INSERTF(m, s->x.k, s->v);			\
		}							\
		break;
	case_SM_CPY_InsertLoop(SM_IntStr, struct SMapIS, sm_is_insert);
	case_SM_CPY_InsertLoop(SM_StrInt, struct SMapSI, sm_si_insert);
	case_SM_CPY_InsertLoop(SM_StrStr, struct SMapSS, sm_ss_insert);
	case_SM_CPY_InsertLoop(SM_StrPtr, struct SMapSP, sm_sp_insert);
#undef case_SM_CPY_InsertLoop
	default:
		break;
	}
	return *m;
}
コード例 #11
0
ファイル: smartall.c プロジェクト: rkorzeniewski/bacula
void *sm_realloc(const char *fname, int lineno, void *ptr, unsigned int size)
{
   unsigned osize;
   void *buf;
   char *cp = (char *) ptr;

   Dmsg4(DT_MEMORY|50, "sm_realloc %s:%d %p %d\n", get_basename(fname), (uint32_t)lineno, ptr, size);
   if (size <= 0) {
      e_msg(fname, lineno, M_ABORT, 0, _("sm_realloc size: %d\n"), size);
   }

   /*  If  the  old  block  pointer  is  NULL, treat realloc() as a
      malloc().  SVID is silent  on  this,  but  many  C  libraries
      permit this.  */
   if (ptr == NULL) {
      return sm_malloc(fname, lineno, size);
   }

   /* If the old and new sizes are the same, be a nice guy and just
      return the buffer passed in.  */
   cp -= HEAD_SIZE;
   struct abufhead *head = (struct abufhead *)cp;
   osize = head->ablen - (HEAD_SIZE + 1);
   if (size == osize) {
      return ptr;
   }

   /* Sizes differ.  Allocate a new buffer of the  requested  size.
      If  we  can't  obtain  such a buffer, act as defined in SVID:
      return NULL from  realloc()  and  leave  the  buffer  in  PTR
      intact.  */

// sm_buffers--;
// sm_bytes -= head->ablen;

   if ((buf = smalloc(fname, lineno, size)) != NULL) {
      memcpy(buf, ptr, (int)sm_min(size, osize));
      /* If the new buffer is larger than the old, fill the balance
         of it with "designer garbage". */
      if (size > osize) {
         memset(((char *) buf) + osize, 0x55, (int) (size - osize));
      }

      /* All done.  Free and dechain the original buffer. */
      sm_free(fname, lineno, ptr);
   }
   Dmsg4(DT_MEMORY|60, _("sm_realloc %d at %p from %s:%d\n"), size, buf, get_basename(fname), (uint32_t)lineno);
   return buf;
}
コード例 #12
0
ファイル: im.c プロジェクト: Daksh/tuxpaint-0.9.21
/**
* Free the State Machine resources.
*/
static void sm_free(STATE_MACHINE* sm)
{
  if(sm->next) {
    int i = 0;

    for(i = 0; i < (int)sm->next_maxsize; i++) {
      STATE_MACHINE* next_state = sm->next[i].state;
      if(next_state) sm_free(next_state);
      sm->next[i].state = NULL;
    }

    free(sm->next);
    sm->next = NULL;
  }

  memset(sm, 0, sizeof(STATE_MACHINE));
}
コード例 #13
0
ファイル: fsm.c プロジェクト: rafaelroquetto/fsmgenerator
int main(int argc, char *argv[])
{
    struct state_machine *sm;
    char *filename;

    int nstates;
    int i;
    int use_goto;

    use_goto = is_goto(argc, argv);

    sm = sm_make();

    sm->tokens = read_tokens();

    if (sm->tokens == NULL)
        panic("Invalid token input");

    read_nstates(sm);
    read_initial_state(sm);
    read_final_states(sm);

    setup_transitions(sm);

    printf("Output filename: ");
    fflush(stdout);

    filename = read_line();

    if (use_goto)
        write_output_goto(sm, filename);
    else
        write_output_func(sm, filename);

    sm_free(sm);

    return 0;
}
コード例 #14
0
ファイル: sexp-datatype.c プロジェクト: AxelNennker/openscap
void SEXP_datatypeTbl_free(SEXP_datatypeTbl_t *t)
{
        rbt_str_free(t->tree);
        sm_free(t);
        return;
}
コード例 #15
0
ファイル: rbt_i64.c プロジェクト: GovReady/openscap
static void rbt_i64_node_free(struct rbt_node *n)
{
        if (n != NULL)
                sm_free(rbt_node_ptr(n));
}
コード例 #16
0
ファイル: counter.c プロジェクト: ifzz/libsrt
int main(int argc, const char **argv)
{
	if (argc < 3)
		return syntax_error(argv, 5);
	int csize = atoi(argv[1]), climit0 = atoi(argv[2]);
	if (csize < 1 || csize > 4)
		return syntax_error(argv, 6);
	if (climit0 < 0)
		return syntax_error(argv, 7);
	int exit_code = 0;
	size_t count = 0;
	size_t cmax = csize == 4 ? 0xffffffff :
				   0xffffffff & ((1 << (csize * 8)) - 1);
	size_t climit = climit0 ? S_MIN((size_t)climit0, cmax) : cmax;
#ifdef COUNTER_USE_BITSET
	#define COUNTER_SET(val) sb_set(&bs, val)
	#define COUNTER_POPCOUNT sb_popcount(bs)
	sb_t *bs = sb_alloc(0);
	sb_eval(&bs, cmax);
#else
	#define COUNTER_SET(val) sm_uu32_insert(&m, val, 1)
	#define COUNTER_POPCOUNT sm_size(m)
	sm_t *m = sm_alloc(SM_U32U32, 0);
#endif
	unsigned char buf[3 * 4 * 128];
	int i;
	ssize_t l;
	for (;;) {
		l = read(0, buf, sizeof(buf));
		l = (l / csize) * csize;
		if (l <= 0)
			break;
		#define CNTLOOP(inc, val)			\
			for (i = 0; i < l; i += inc) {		\
				COUNTER_SET(val);		\
				count++;			\
				if (COUNTER_POPCOUNT >= climit)	\
					goto done;		\
			}
		switch (csize) {
		case 1:	CNTLOOP(1, buf[i]);
			break;
		case 2:	CNTLOOP(2, (size_t)(buf[i] << 8 | buf[i + 1]));
			break;
		case 3:	CNTLOOP(3, (size_t)(buf[i] << 16 | buf[i + 1] << 8 | buf[i + 2]));
			break;
		case 4:	CNTLOOP(4, (size_t)buf[i] << 24 |
				   (size_t)buf[i + 1] << 16 |
				   (size_t)buf[i + 2] << 8 |
				   (size_t)buf[i + 3]);
			break;
		default:
			goto done;
		}
		#undef CNTLOOP
	}
done:
	printf(FMT_ZU ", " FMT_ZU, count, COUNTER_POPCOUNT);
#ifdef COUNTER_USE_BITSET
	sb_free(&bs);
#else
	sm_free(&m);
#endif
	return exit_code;
}
コード例 #17
0
ファイル: state.c プロジェクト: jquick/pioneers
void sm_dec_use_count(StateMachine * sm)
{
	if (!--sm->use_count && sm->is_dead)
		sm_free(sm);
}
コード例 #18
0
ファイル: smartall.c プロジェクト: aAnsgarWuestenhagen/bareos
void operator delete(void *buf)
{
   sm_free(__FILE__, __LINE__, buf);
}
コード例 #19
0
ファイル: smartall.c プロジェクト: rkorzeniewski/bacula
void operator delete(void *buf)
{
// Dmsg1(000, "free called %p\n", buf);
   sm_free(__FILE__, __LINE__, buf);
}