コード例 #1
0
ファイル: mem.c プロジェクト: justinbrewer/SACS
/** \brief Initializes memory module

    Initializes root of memory tree and marks the lowest gigabyte as locked.
 */
int mem_init(void){
  root = _create_node(ROOT_SIZE,0,0);
  root->state = SPLIT;

  root->left = _create_node(ROOT_SIZE-1,0,root);
  root->left->state = SPLIT;
  root->left->left = _create_node(ROOT_SIZE-2,0,root->left);
  root->left->left->state = LOCKED;
  return 0;
}
コード例 #2
0
node*	module::_add_node(const string &node_name, const string &node_type, map<string, module*> &map_module, map<string, cell*> &map_cell) {
	node* new_node;
	map<string, module*>::iterator ite_m;
	map<string, cell*>::iterator ite_c;
	if ((ite_c = map_cell.find(node_type)) != map_cell.end()) {
		new_node = _create_node(node_name, TYPE_CELL, ite_c->second, NULL);
	}
	else if ((ite_m = map_module.find(node_type)) != map_module.end()) {
		new_node = _create_node(node_name, TYPE_MODULE, NULL, ite_m->second);
	}
	else {
		new_node = NULL;
	}
	return new_node;
}
コード例 #3
0
ファイル: gtree.c プロジェクト: nickbjohnson4224/kerplunk
struct gtree_node *gtree_child(struct gtree_node *node, go_move move, bool expand) {
    assert(node);

    const int index = gtree_move_index(node, move);
    if (index < 0) {
        return NULL;
    }

    const struct gtree_schema *schema = node->schema;
    struct gtree_node **children = (void*) 
        &node->_vdata[schema->movedata_base_offset + node->num_moves * sizeof(go_move)];
    
    if (children[index]) {
        return children[index];
    }
    else if (!expand) {
        return NULL;
    }
    else {
        // expand child node
        struct gtree_node *child = _create_node(node, move);
        if (!child) {
            // error creating child
            return NULL;
        }

        children[index] = child;
        return child;
    }
}
コード例 #4
0
ファイル: config.c プロジェクト: inteos/WBSAirback
struct config_node *clone_config_node_with_mem(struct dm_pool *mem, const struct config_node *cn,
					       int siblings)
{
	struct config_node *new_cn;

	if (!cn)
		return NULL;

	if (!(new_cn = _create_node(mem))) {
		log_error("Failed to clone config node.");
		return NULL;
	}

	if ((cn->key && !(new_cn->key = dm_pool_strdup(mem, cn->key)))) {
		log_error("Failed to clone config node key.");
		return NULL;
	}

	if ((cn->v && !(new_cn->v = _clone_config_value(mem, cn->v))) ||
	    (cn->child && !(new_cn->child = clone_config_node_with_mem(mem, cn->child, 1))) ||
	    (siblings && cn->sib && !(new_cn->sib = clone_config_node_with_mem(mem, cn->sib, siblings))))
		return_NULL; /* 'new_cn' released with mem pool */

	return new_cn;
}
コード例 #5
0
ファイル: hash.c プロジェクト: Distrotech/LVM2
int dm_hash_insert_allow_multiple(struct dm_hash_table *t, const char *key,
				  const void *val, uint32_t val_len)
{
	struct dm_hash_node *n;
	struct dm_hash_node *first;
	int len = strlen(key) + 1;
	unsigned h;

	n = _create_node(key, len);
	if (!n)
		return 0;

	n->data = (void *)val;
	n->data_len = val_len;

	h = _hash(key, len) & (t->num_slots - 1);

	first = t->slots[h];

	if (first)
		n->next = first;
	else
		n->next = 0;
	t->slots[h] = n;

	t->num_nodes++;
	return 1;
}
コード例 #6
0
ファイル: config.c プロジェクト: inteos/WBSAirback
static struct config_node *_section(struct parser *p)
{
	/* IDENTIFIER SECTION_B_CHAR VALUE* SECTION_E_CHAR */
	struct config_node *root, *n, *l = NULL;
	if (!(root = _create_node(p->mem)))
		return_0;

	if (!(root->key = _dup_tok(p)))
		return_0;

	match(TOK_IDENTIFIER);

	if (p->t == TOK_SECTION_B) {
		match(TOK_SECTION_B);
		while (p->t != TOK_SECTION_E) {
			if (!(n = _section(p)))
				return_0;

			if (!root->child)
				root->child = n;
			else
				l->sib = n;
			n->parent = root;
			l = n;
		}
		match(TOK_SECTION_E);
	} else {
		match(TOK_EQ);
		if (!(root->v = _value(p)))
			return_0;
	}

	return root;
}
コード例 #7
0
ファイル: shell_impl.c プロジェクト: seckcoder/lang-learn
NodeType *create_param(bool is_option, char *param) {
  /*printf("create_param\n");*/
  NodeType *pn = _create_node(TypeParam);
  NodeParam param_node;
  param_node.param = format_param(is_option, param);
  pn->param = param_node;
  return pn;
}
コード例 #8
0
ファイル: shell_impl.c プロジェクト: seckcoder/lang-learn
NodeType *create_pipe(NodeType *cmd, NodeType *pipe) {
  /*printf("create_pipe\n");*/
  NodeType *pn = _create_node(TypePipe);
  NodePipe pipe_node;
  pipe_node.cmd = cmd;
  pipe_node.pipe = pipe;
  pn->pipe = pipe_node;
  return pn;
}
コード例 #9
0
ファイル: node.c プロジェクト: zouxiaoliang/nessDB
int node_create_light(NID nid,
                      uint32_t height,
                      uint32_t children,
                      int version,
                      struct env *e,
                      struct node **n)
{
	return _create_node(nid, height, children, version, n, e, 1);
}
コード例 #10
0
ファイル: shell_impl.c プロジェクト: seckcoder/lang-learn
NodeType *create_pair(NodeType *car, NodeType *cdr) {
  /*printf("create_pair\n");*/
  NodeType *pn = _create_node(TypePair);
  NodePair pair_node;
  pair_node.car = car;
  pair_node.cdr = cdr;
  pn->pair = pair_node;
  return pn;
}
コード例 #11
0
ファイル: shell_impl.c プロジェクト: seckcoder/lang-learn
NodeType *create_redir(NodeType *cmd, NodeType *file) {
  /*printf("create_redir\n");*/
  NodeType *pn = _create_node(TypeRedir);
  NodeRedir redir_node;
  redir_node.cmd = cmd;
  redir_node.file = file;
  pn->redir = redir_node;
  return pn;
}
コード例 #12
0
ファイル: shell_impl.c プロジェクト: seckcoder/lang-learn
NodeType *create_cmd(char* cmd, NodeType *params) {
  /*printf("create_cmd\n");*/
  NodeType *pn = _create_node(TypeCmd);
  NodeCmd cmd_node;
  cmd_node.cmd = cmd;
  cmd_node.params = params;
  pn->cmd = cmd_node;
  return pn;
}
コード例 #13
0
ファイル: mem.c プロジェクト: justinbrewer/SACS
uint32_t _dyn_alloc(struct mem_node* node, uint32_t size, mem_alloc_flags flags){
  uint32_t res;
  switch(node->state){
  case FREE:
    if(node->size == size || node->size == MINIMUM_SIZE){
      node->state = FULL;
      if(!(flags & MEM_FAKE_ALLOC)){
	node->mem = malloc(1 << size);
      }
      return node->loc;
    }else{
      node->state = SPLIT;
      node->left = _create_node(node->size-1,node->loc,node);
      return _dyn_alloc(node->left,size,flags);
    }

  case LOCKED:
    if(!(flags & MEM_USE_LOCKED)){
      return INSUFFICIENT_SPACE;
    }
  case SPLIT:
    if(node->left == 0){
      node->left = _create_node(node->size-1,node->loc,node);
      return _dyn_alloc(node->left,size,flags);
    }else{
      res = _dyn_alloc(node->left,size,flags);
      if(res == INSUFFICIENT_SPACE){
	if(node->right == 0){
	  node->right = _create_node(node->size-1,node->loc+(1<<(node->size-1)),node); //TESTME
	  return _dyn_alloc(node->right,size,flags);
	}else{
	  return _dyn_alloc(node->right,size,flags);
	}
      }else{
	return res;
      }
    }

  case FULL:
    return INSUFFICIENT_SPACE;
  }
  return 0;
}
コード例 #14
0
ファイル: libdm-config.c プロジェクト: amyvmiwei/bittern
static struct dm_config_node *_make_node(struct dm_pool *mem,
					 const char *key_b, const char *key_e,
					 struct dm_config_node *parent)
{
	struct dm_config_node *n;

	if (!(n = _create_node(mem)))
		return_NULL;

	n->key = _dup_token(mem, key_b, key_e);
	if (parent) {
		n->parent = parent;
		n->sib = parent->child;
		parent->child = n;
	}
	return n;
}
コード例 #15
0
ファイル: libdm-config.c プロジェクト: Find7s/Lvm_for_Android
struct dm_config_node *dm_config_create_node(struct dm_config_tree *cft, const char *key)
{
	struct dm_config_node *cn;

	if (!(cn = _create_node(cft->mem))) {
		log_error("Failed to create config node.");
		return NULL;
	}
	if (!(cn->key = dm_pool_strdup(cft->mem, key))) {
		log_error("Failed to create config node's key.");
		return NULL;
	}
	cn->parent = NULL;
	cn->v = NULL;

	return cn;
}
コード例 #16
0
ファイル: hash.c プロジェクト: pts/pts-static-libdevmapper
int dm_hash_insert_binary(struct dm_hash_table *t, const char *key,
			  uint32_t len, void *data)
{
	struct dm_hash_node **c = _find(t, key, len);

	if (*c)
		(*c)->data = data;
	else {
		struct dm_hash_node *n = _create_node(key, len);

		if (!n)
			return 0;

		n->data = data;
		n->next = 0;
		*c = n;
		t->num_nodes++;
	}

	return 1;
}
コード例 #17
0
ファイル: config.c プロジェクト: inteos/WBSAirback
struct config_node *create_config_node(struct config_tree *cft, const char *key)
{
	struct cs *c = (struct cs *) cft;
	struct config_node *cn;

	if (!(cn = _create_node(c->mem))) {
		log_error("Failed to create config node.");
		return NULL;
	}
	if (!(cn->key = dm_pool_strdup(c->mem, key))) {
		log_error("Failed to create config node's key.");
		return NULL;
	}
	if (!(cn->v = _create_value(c->mem))) {
		log_error("Failed to create config node's value.");
		return NULL;
	}
	cn->parent = NULL;
	cn->v->type = CFG_INT;
	cn->v->v.i = 0;
	cn->v->next = NULL;
	return cn;
}