void check_block(const Block *b) { for (auto input : b->inputs()) { check_value(input); JIT_ASSERT(input->node()->kind_ == kParam); } for (auto n : b->nodes()) { JIT_ASSERT(n->kind_ != kParam); JIT_ASSERT(n->kind_ != kReturn); check_node(n); } JIT_ASSERT(b->output_->kind() == kReturn); check_node(b->output_); // all_nodes // - inputs_, output_ and nodes_ are all included in all_nodes // - all_nodes does not contain dead nodes??? (likely to be temporarily // suspended). Weaker: all_nodes contains all inputs and returns // - only one return node??? node_set nodes_set(ALL_OF(b->nodes())); node_set inputs_set {b->input_}; node_set output_set {b->output_}; // TODO: Make a more type safe std::includes wrapper which disallows use on // non-ordered containers JIT_ASSERT(std::includes(ALL_OF(all_nodes_set), ALL_OF(nodes_set))); JIT_ASSERT(std::includes(ALL_OF(all_nodes_set), ALL_OF(inputs_set))); JIT_ASSERT(std::includes(ALL_OF(all_nodes_set), ALL_OF(output_set))); sum_set.insert(ALL_OF(nodes_set)); sum_set.insert(ALL_OF(inputs_set)); sum_set.insert(ALL_OF(output_set)); }
/*===================================== * check_node -- check node for bad pointers * and bad levels, and continue traverse * 2001/02/18, Perry Rapp *===================================*/ static void check_node (CNSTRING n0key, NODE node, INT level) { BOOLEAN lineage=FALSE; /* ignore lineage links - they are checked elsewhere */ if (level==1) { INT i; for (i=0; i<ARRSIZE(lineage_tags); i++) { if (eqstr(ntag(node), lineage_tags[i])) { lineage=TRUE; break; } } } /* TO DO: How do we tell non-pointers that *ought* to be pointers, eg "1 SOUR <FamilyHistory>" ? */ if (!lineage) { STRING skey = rmvat(nval(node)); if (skey) { NODE xnode = qkey_to_type(skey); if (!xnode) { report_error(ERR_BADPOINTER , _("Bad pointer (in %s): %s") , n0key, nval(node)); } } } if (nchild(node)) check_node(n0key, nchild(node), level+1); if (nsibling(node)) check_node(n0key, nsibling(node), level); }
void check_node(avl_tree_node_t *atn, multigrid_t *mg, multigrid_graph_t *mg_g) { struct T *t = atn->data; avl_tree_node_t *atn_from, *atn_to; graph_vertex_idx_t from, to; atn_from = avl_tree_get( &mg_g->grid_to_graph_vertex, (avl_tree_key_t)multigrid_get_grid(mg, t->from) ); atn_to = avl_tree_get( &mg_g->grid_to_graph_vertex, (avl_tree_key_t)multigrid_get_grid(mg, t->to) ); from = *(graph_vertex_idx_t *)atn_from->data; to = *(graph_vertex_idx_t *)atn_to->data; graph_edge_found_t gef = graph_remove_edge(&mg_g->graph, from, to); ck_assert_int_eq(gef.found, true); free(gef.data); if (atn->left) check_node(atn->left, mg, mg_g); if (atn->right) check_node(atn->right, mg, mg_g); }
struct node *check_node(struct bintree *root,struct node *node,short depth) { short cmp; cmp=bin_compare(root->node->square,node->square); if(cmp<0) { if(!root->lson) { root->lson=set_node(root,node,depth); return NULL; } else return check_node(root->lson,node,depth+1); } else if(cmp>0) { if(!root->rson) { root->rson=set_node(root,node,depth); return NULL; } else return check_node(root->rson,node,depth+1); } return root->node; }
// FIXME - deal with whitespace! static void got_inventory_items_resp(SoupSession *session, SoupMessage *msg, gpointer user_data) { //USER_PRIV_DEF(user_data); //GRID_PRIV_DEF(sim); inv_items_req *req = (inv_items_req*)user_data; user_grid_glue* user_glue = req->user_glue; xmlDocPtr doc; xmlNodePtr node; struct inventory_contents* inv; user_grid_glue_deref(user_glue); if(msg->status_code != 200) { printf("ERROR: Inventory request failed: got %i %s\n",(int)msg->status_code,msg->reason_phrase); goto fail; } printf("DEBUG: inventory folder content resp {{%s}}\n", msg->response_body->data); doc = xmlReadMemory(msg->response_body->data, msg->response_body->length, "inventory.xml", NULL, 0); if(doc == NULL) { printf("ERROR: inventory XML parse failed\n"); goto fail; } node = xmlDocGetRootElement(doc); if(strcmp((char*)node->name, "InventoryCollection") != 0) { printf("ERROR: unexpected root node %s\n",(char*)node->name); goto free_fail; } node = node->children; if(!check_node(node,"Folders")) goto free_fail; inv = caj_inv_new_contents_desc(req->folder_id); parse_inv_folders(doc, node->children, inv); node = node->next; if(!check_node(node,"Items")) goto free_inv_fail; parse_inv_items(doc, node->children, inv); // there's a UserID node next, but it's just the null UUID anyway. req->cb(inv, req->cb_priv); caj_inv_free_contents_desc(inv); xmlFreeDoc(doc); delete req; return; free_inv_fail: caj_inv_free_contents_desc(inv); free_fail: xmlFreeDoc(doc); fail: req->cb(NULL, req->cb_priv); delete req; printf("ERROR: inventory response parse failure\n"); return; }
END_TEST START_TEST(check_node_test) { struct pbsnode pnode; login_node ln(&pnode); pnode.nd_slots.add_execution_slot(); fail_unless(check_node(&ln, NULL) != NULL); pnode.nd_slots.mark_as_used(0); fail_unless(check_node(&ln, NULL) == NULL); }
//------------------------------------------------------------------------------------------------- void rotate_left( Node *n ) { check_node(n, "Rotate left: n == NIL"); check_node(n->right, "Rotate left: n->right == NIL"); Node *r = n->right; if (n->parent == NULL) { root = r; } else { if (n == n->parent->left) n->parent->left = r; else n->parent->right = r; } if (r != NULL) { r->parent = n->parent; } n->right = r->left; if (r->left != NULL) { r->left->parent = n; } r->left = n; n->parent = r; /* Node *p = n->parent; Node *r = n->right->left; n->parent = n->right; n->right->parent = p; if(p) { if(n == p->right) { p->right = n->right; } else { p->left = n->right; } } else { root = n->right; } n->right->left = n; n->right = r; */ error: return; }
static void check_nodelist(test_nodes* pnodes, UINT32 num, const char* str) { static char str_tmp[128]; for (UINT32 i = 0; i < num; ++i) { sprintf(str_tmp, "%s<%d>", str, i); check_node(pnodes + i, str_tmp); } }
/*** * Iterate through all nodes of waterways in pass 3 if way is coastline * or riverbank. Otherwise iterate just through the nodes between * firstnode and lastnode. */ void way(const osmium::Way& way) { if (is_valid(way)) { if (check_all_nodes(way)) { for (auto node : way.nodes()) { check_node(node); } } else { if (way.nodes().size() > 2) { for (auto node = way.nodes().begin() + 1; node != way.nodes().end() - 1; ++node) { check_node(*node); } } } } }
graph_t * new_graph (unsigned int n, char **lbl){ graph_t *grafo; unsigned int i; if( (n <= ZERO) || !lbl || !check_node(lbl,n)) { errno = EINVAL; return NULL; } MALLOC_IF(grafo, sizeof(graph_t), UNO) if( !( MALLOC(grafo->node, sizeof(node_t), n)) ) { free(grafo); return NULL; } grafo->size = n; for(i = ZERO; i<n; i++){ ((grafo-> node)+i) -> adj = NULL; if( !( MALLOC( ((grafo-> node)+i)->label, sizeof(char), LLABEL+UNO ) ) ){ free_graph(&grafo); return NULL; } strcpy( (((grafo-> node)+i) -> label) , lbl[i]); } return grafo; }
EC_API ec_list ec_list_copy( ec_list list ) { ec_list newlist; ec_list_iterator iter; ec_list_node node, newnode, last; check_list(list); newlist = ec_list_create(); if (! newlist) return NULL; last = NULL; iter = ec_list_iterator_create( list ); while ((node = ec_list_iterator_next( iter ))) { check_node(node); newnode = alloc_node( KEY(node), DATA(node) ); ASSERT( newnode ); if (! newnode) return NULL; /* argh ! */ if (last) NEXT(last) = newnode; else { HEAD(newlist) = newnode; last = newnode; } } ec_list_iterator_destroy( iter ); check_list(newlist); return newlist; }
EC_API ec_list ec_list_remove( ec_list list, ec_list_node node ) { ec_list_node prev, cur; check_list(list); check_node(node); if (! node) return list; prev = NULL; cur = HEAD(list); while (cur && (cur != node)) { prev = cur; cur = NEXT(cur); } if (cur != node) return list; ASSERT( cur && (cur == node) ); if (prev) NEXT(prev) = NEXT(node); else HEAD(list) = NEXT(node); NEXT(node) = NULL; check_list(list); return list; }
//------------------------------------------------------------------------------------------------- void rotate_right( Node *n ) { check_node(n, "Rotate right: n == NIL"); check_node(n->left, "Rotate right: n->left == NIL"); Node *l = n->left; if (n->parent == NULL) { root = l; } else { if (n == n->parent->left) n->parent->left = l; else n->parent->right = l; } if (l != NULL) { l->parent = n->parent; } n->left = l->right; if (l->right != NULL) { l->right->parent = n; } l->right = n; n->parent = l; /* Node *p = n->parent; Node *l = n->left->right; n->parent = n->left; n->left->parent = p; if(p) { if(n == p->left) { p->left = n->left; } else { p->right = n->left; } } else { root = n->left; } n->left->right = n; n->left = l; */ error: return; }
void test() { NodePtr hello = new Leaf("hello"); NodePtr world = new Leaf("world"); //check_node(hello); NodePtr hw = hello->concat_with(world); //hw->debug_print(); check_node(hw); //concatenation for (int i = 0; i<100; i++) { if (i%20 == 0) std::cout<<i<<std::endl; hw = hw->concat_with(hello); //hw->debug_print(); assert(check_node(hw)); } assert(check_node(hw)); hw->debug_print(); //random access for (int i = 0; i<100; i++) { Iterator iter = Iterator(hw); int pos = 0; std::string s = hw->as_string(); while (pos < hw->length()) { //std::cout<<pos<<" "; assert(s[pos] == iter.current()); int d = rand()%100; pos += d; iter.advance(d); } assert(!iter.valid); //std::cout<<std::endl; } //slices for (int i = 0; i<100; i++) { int begin = rand()%(hw->length()+1); int end = begin+rand()%(hw->length()-begin+1); NodePtr slice = hw->slice(begin, end); assert(check_node(slice)); std::cout<<begin<<" "<<end<<std::endl; } std::cout<<"hw depth "<<hw->depth()<<std::endl; }
struct pbsnode *find_fitting_node( struct prop *needed) { struct pbsnode *pnode = NULL; login_node *ln; login_node *ordered_ln; int iter = -1; int ordered_iter; int index; resizable_array *ordered = initialize_resizable_array(logins.ra->num + 1); /* create a sorted list of the logins */ while ((ln = (login_node *)next_thing(logins.ra, &iter)) != NULL) { /* if ordered is empty just insert without attempting to sort */ if (ordered->num == 0) insert_thing(ordered, ln); else { ordered_iter = -1; index = ordered->slots[ALWAYS_EMPTY_INDEX].next; while ((ordered_ln = (login_node *)next_thing(ordered, &ordered_iter)) != NULL) { if (ln->times_used <= ordered_ln->times_used) { insert_thing_before(ordered, ln, index); break; } index = ordered_iter; } /* insert if it hasn't been inserted yet */ if (ordered_ln == NULL) insert_thing(ordered, ln); } } iter = -1; while ((ln = (login_node *)next_thing(ordered, &iter)) != NULL) { if ((pnode = check_node(ln, needed)) != NULL) { ln->times_used++; free_resizable_array(ordered); return(pnode); } } free_resizable_array(ordered); return(NULL); } /* END find_fitting_node() */
int rb_tree_check(rb_tree *t) { int nblack; if (nil.c != BLACK) return 0; if (nil.p != NIL || nil.r != NIL || nil.l != NIL) return 0; if (t->root == NIL) return 1; if (t->root->c != BLACK) return 0; return check_node(t->root, &nblack, t); }
static bool check_node(WTiling *ws, WSplit *split) { if(split->parent) return check_node(ws, (WSplit*)split->parent); if((split->ws_if_root!=(void*)ws)){ warn(TR("Split not on workspace.")); return FALSE; } return TRUE; }
EC_API ec_list_node ec_list_append( ec_list list, EcAny key, EcAny data ) { ec_list_node last, newnode; check_list(list); last = ec_list_tail( list ); newnode = alloc_node( key, data ); ASSERT( newnode ); if (! newnode) return NULL; /* argh ! */ if (last) { check_node(last); NEXT(last) = newnode; } else HEAD(list) = newnode; check_node(newnode); return newnode; }
int program(ast::Program* program) { assert(program != nullptr); for (auto it = program->body.begin(); it != program->body.end(); ++it) { declare_node(it->get()); } for (auto it = program->body.begin(); it != program->body.end(); ++it) { check_node(it->get()); } return EXIT_SUCCESS; }
static void deassembleTree(HQTreeNode* pnodes, const char* str) { char str_temp[64]; for (UINT32 i = 0; i < 6; ++i) { pnodes[i].Detach(); } for (UINT32 i = 0; i < 6; ++i) { test_nodes temp = {pnodes + i, NULL, NULL, NULL, NULL, NULL, NULL, NULL}; sprintf(str_temp, "%s[%d]", str, i); check_node(&temp, str); } }
/* return next block to free; search backwards, first not in collection, then in collection, return NULL at the end */ static MemBlock *next_to_free(void) { MemBlock *block; int count; /* not in collection */ DL_FOREACH(g_mem_blocks, block) { check_node(block); if (!block->flags.in_collection) return block; }
/*============================================== * check_node_recursively -- Check node and all descendant nodes *============================================*/ static void check_node_recursively (NODE node, NODE parent, INT level, CNSTRING key, CNSTRING scope) { NODE child=0; check_node(node, parent, level, key, scope); for (child = nchild(node); child; child = nsibling(child)) { check_node_recursively(child, node, level+1, key, scope); } }
EC_API EcBool ec_list_finddata( ec_list list, EcAny key, EcAny *data ) { ec_list_node node; check_list(list); node = ec_list_find( list, key ); if (! node) return FALSE; check_node(node); if (data) *data = DATA(node); return TRUE; }
EC_API ec_list_node ec_list_tail( ec_list list ) { ec_list_node node; check_list(list); /* find the last node */ for (node = HEAD(list); node && NEXT(node); node = NEXT(node)) check_node(node) ; return node; }
static void check_node_and_range(int inode, enum e_route_type route_type) { /* Checks that inode is within the legal range, then calls check_node to * * check that everything else about the node is OK. */ if (inode < 0 || inode >= num_rr_nodes) { vpr_printf(TIO_MESSAGE_ERROR, "in check_node_and_range: rr_node #%d is out of legal, range (0 to %d).\n", inode, num_rr_nodes - 1); exit(1); } check_node(inode, route_type); }
static int check_node(rb_node *n, int *nblack, rb_tree *t) { int nbl, nbr; rb_compare compare = t->compare; if (n == NIL) { *nblack = 0; return 1; } if (n->r != NIL && n->r->p != n) return 0; if (n->r != NIL && compare(n->r->k, n->k) < 0) return 0; if (n->l != NIL && n->l->p != n) return 0; if (n->l != NIL && compare(n->l->k, n->k) > 0) return 0; if (n->c == RED) { if (n->r != NIL && n->r->c == RED) return 0; if (n->l != NIL && n->l->c == RED) return 0; } if (!(check_node(n->r, &nbl, t) && check_node(n->l, &nbr, t))) return 0; if (nbl != nbr) return 0; *nblack = nbl + (n->c == BLACK); return 1; }
std::vector< Ellipsoid_rasterizer::EuclideanVector >& Ellipsoid_rasterizer::rasterize() { GsTLInt center_id = cursor_.node_id( center_[0], center_[1], center_[2] ); appli_assert( center_id >= 0 && center_id < int(already_visited_.size()) ); already_visited_[ center_id ] = true; s_.push( center_id ); EuclideanVector west(-1,0,0); EuclideanVector east(1,0,0); EuclideanVector south(0,-1,0); EuclideanVector north(0,1,0); EuclideanVector down(0,0,-1); EuclideanVector up(0,0,1); // move away from center, until we reach the border of the ellipsoid while( ! s_.empty() ) { GsTLInt id = s_.top(); s_.pop(); GsTLGridNode loc; cursor_.coords( id, loc[0], loc[1], loc[2] ); check_node( loc+west ); check_node( loc+east ); check_node( loc+north ); check_node( loc+south ); check_node( loc+up ); check_node( loc+down ); } return ellipsoid_nodes_; }
EC_API ec_list_node ec_list_prepend( ec_list list, EcAny key, EcAny data ) { ec_list_node newnode; check_list(list); newnode = alloc_node( key, data ); ASSERT( newnode ); if (! newnode) return NULL; /* argh ! */ NEXT(newnode) = HEAD(list); HEAD(list) = newnode; check_node(newnode); return newnode; }
static isc_result_t check_hints(dns_db_t *db) { isc_result_t result; dns_rdataset_t rootns; dns_dbiterator_t *dbiter = NULL; dns_dbnode_t *node = NULL; isc_stdtime_t now; dns_fixedname_t fixname; dns_name_t *name; dns_rdatasetiter_t *rdsiter = NULL; isc_stdtime_get(&now); dns_fixedname_init(&fixname); name = dns_fixedname_name(&fixname); dns_rdataset_init(&rootns); (void)dns_db_find(db, dns_rootname, NULL, dns_rdatatype_ns, 0, now, NULL, name, &rootns, NULL); result = dns_db_createiterator(db, 0, &dbiter); if (result != ISC_R_SUCCESS) goto cleanup; result = dns_dbiterator_first(dbiter); while (result == ISC_R_SUCCESS) { result = dns_dbiterator_current(dbiter, &node, name); if (result != ISC_R_SUCCESS) goto cleanup; result = dns_db_allrdatasets(db, node, NULL, now, &rdsiter); if (result != ISC_R_SUCCESS) goto cleanup; result = check_node(&rootns, name, rdsiter); if (result != ISC_R_SUCCESS) goto cleanup; dns_rdatasetiter_destroy(&rdsiter); dns_db_detachnode(db, &node); result = dns_dbiterator_next(dbiter); } if (result == ISC_R_NOMORE) result = ISC_R_SUCCESS; cleanup: if (dns_rdataset_isassociated(&rootns)) dns_rdataset_disassociate(&rootns); if (rdsiter != NULL) dns_rdatasetiter_destroy(&rdsiter); if (node != NULL) dns_db_detachnode(db, &node); if (dbiter != NULL) dns_dbiterator_destroy(&dbiter); return (result); }
int scribble_check_defined_roles(st_tree *tree) { assert(tree != NULL); assert(tree->root != NULL); if (tree->info->type != ST_TYPE_GLOBAL) { fprintf(stderr, "%s:%d %s Given protocol is not global protocol\n", __FILE__, __LINE__, __FUNCTION__); return 1; // Cannot check so always return error } t = tree; return check_node(tree->root, tree->info->roles, tree->info->nrole); }