C++ (Cpp) BlockHeapFree Examples

Example #1

File: dbuf.c Project: mdharris/ircd

void
dbuf_delete(struct dbuf_queue *qptr, size_t count)
{
  dlink_node *ptr;
  struct dbuf_block *first;

  assert(qptr->total_size >= count);
  if (count == 0)
    return;

  /* free whole blocks first.. */
  while (1)
  {
    if (!count)
      return;
    ptr = qptr->blocks.head;
    first = ptr->data;
    if (count < first->size)
      break;

    qptr->total_size -= first->size;
    count -= first->size;
    dlinkDelete(ptr, &qptr->blocks);
    free_dlink_node(ptr);
    BlockHeapFree(dbuf_heap, first);
  }

  /* ..then remove data from the beginning of the queue */
  first->size -= count;
  qptr->total_size -= count;
  memmove((void *) &first->data, (void *) &first->data[count], first->size);
}

Example #2

File: dlink.c Project: BackupTheBerlios/phoenixfn-svn

/* frees a node */
void node_free(node_t *n)
{
        /* free it */
        BlockHeapFree(node_heap, n);

        /* down the count */
        claro_state.node--;
}

Example #3

File: dlink.c Project: danopia/atheme

/* frees a node */
void node_free(node_t *n)
{
	return_if_fail(n != NULL);

        /* free it */
        BlockHeapFree(node_heap, n);

        /* down the count */
        claro_state.node--;
}

Example #4

File: s_bsd.c Project: mindspeaker/oftc-hybrid

void
close_callback(uv_handle_t *handle)
{
  uv_tcp_t *tcp_handle = (uv_tcp_t*)handle;

  switch(handle->type)
  {
    case UV_TCP:
      if(tcp_handle->connect_req != NULL)
        BlockHeapFree(connect_handle_heap, tcp_handle->connect_req);
      BlockHeapFree(tcp_handle_heap, handle);
      break;
    case UV_UDP:
      BlockHeapFree(udp_handle_heap, handle);
      break;
    default:
      MyFree(handle);
      break;
  }
}

Example #5

File: client.c Project: Cloudxtreme/ircd-ratbox

void _free_client(struct Client* client_p)
{
  assert(NULL != client_p);
  assert(&me != client_p);
  assert(NULL == client_p->prev);
  assert(NULL == client_p->next);

  if (MyConnect(client_p))
    {
      assert(IsClosing(client_p) && IsDead(client_p));
      
    /*
     * clean up extra sockets from P-lines which have been discarded.
     */
    if (client_p->localClient->listener)
    {
      assert(0 < client_p->localClient->listener->ref_count);
      if (0 == --client_p->localClient->listener->ref_count &&
          !client_p->localClient->listener->active) 
        free_listener(client_p->localClient->listener);
      client_p->localClient->listener = 0;
    }

      if (client_p->localClient->fd >= 0)
	fd_close(client_p->localClient->fd);

      BlockHeapFree(lclient_heap, client_p->localClient);
      --local_client_count;
      assert(local_client_count >= 0);
    }
  else
    {
      --remote_client_count;
    }

  BlockHeapFree(client_heap, client_p);
}

Example #6

File: m_clearchan.c Project: Cloudxtreme/ircd-3

/*
 * free_channel_list
 *
 * inputs       - pointer to dlink_list
 * output       - NONE
 * side effects -
 */
static void free_channel_list(dlink_list *list)
{
  dlink_node *ptr;
  dlink_node *next_ptr;
  struct Ban *actualBan;

  for (ptr = list->head; ptr; ptr = next_ptr)
    {
      next_ptr = ptr->next;

      actualBan = ptr->data;
      MyFree(actualBan->banstr);
      MyFree(actualBan->who);
      BlockHeapFree(ban_heap, actualBan);

      free_dlink_node(ptr);
    }
}

Example #7

File: list.c Project: Adam-/oftc-hybrid

/* free_dlink_node()
 *
 * inputs       - pointer to dlink_node
 * output       - NONE
 * side effects	- free given dlink_node 
 */
void
free_dlink_node(dlink_node *ptr)
{
  BlockHeapFree(dnode_heap, ptr);
}

Example #8

File: linebuf.c Project: Cloudxtreme/ircd-ratbox

static void
linebuf_free(buf_line_t * p)
{
	BlockHeapFree(linebuf_heap, p);
}

Example #9

File: s_bsd.c Project: mindspeaker/oftc-hybrid

void
write_callback(uv_write_t *req, int status)
{
  BlockHeapFree(write_req_heap, req);
}