bool dump_node(TAP_state_t *state, userp_ident_t *root, int lev) { if (!root) return false; userp_ident_t *next= userp_ident_by_name_right(root); if (next) dump_node(state, next, lev+1); TAP_NOTE("%*s(%c) %s", lev*4, "", root->name_tree_node.color? 'R':'B', root->name); next= userp_ident_by_name_left(root); if (next) dump_node(state, next, lev+1); return true; }
void dump_node( struct xmlNode *node ) { if( node == 0 ) { return; } printf( "Node:%s Attr:", node->name ); dump_attr( node->attr_list ); putc( '\n', stdout ); dump_node( node->children ); dump_node( node->sibling ); }
int main( int argc, char **argv ) { FILE *fp = 0; if( argc < 2 ) { fprintf( stderr, "Usage : %s filename.\n", argv[0] ); exit( -1 ); } fp = fopen( argv[1], "r" ); if( fp == 0 ) { fprintf( stderr, "Unable to open %s.\n", argv[1] ); exit( -1 ); } { struct xmlDocument *doc = xmldoc_new( fp ); xml_seterrorfn( error_log ); xml_parse( doc ); dump_node( doc->root ); xmldoc_free( doc ); } fclose( fp ); return 0; }
void dump_node(Node *n, bool same_line, int padding, MappedSubstring orig) { int delta = 0; if (!same_line) { for (int i = 0; i < padding; ++i) { std::cout << " "; } } if (!orig.empty()) { auto s = haystack.find(orig.ref_str); for (int i = orig.l; i <= orig.r && i <= s->second.length(); ++i) { std::cout << s->second[i]; } std::cout << "-"; delta = orig.r - orig.l + 2; if (orig.r == std::numeric_limits<int>::max()) { delta = s->second.length() - orig.l + 2; } } same_line = true; for (auto t_it : n->g) { dump_node(t_it.second.tgt, same_line, padding + delta, t_it.second.sub); same_line = false; } if (same_line) { std::cout << "##" << std::endl; } }
void dump_vector(int indent, Vector *vec) { for (int i = 0; i < vec->length; i++) { dump_node(indent, (Node *)vector_get(vec, i)); } }
void c_genericize (tree fndecl) { FILE *dump_orig; int local_dump_flags; struct cgraph_node *cgn; /* Dump the C-specific tree IR. */ dump_orig = dump_begin (TDI_original, &local_dump_flags); if (dump_orig) { fprintf (dump_orig, "\n;; Function %s", lang_hooks.decl_printable_name (fndecl, 2)); fprintf (dump_orig, " (%s)\n", (!DECL_ASSEMBLER_NAME_SET_P (fndecl) ? "null" : IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)))); fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original)); fprintf (dump_orig, "\n"); if (local_dump_flags & TDF_RAW) dump_node (DECL_SAVED_TREE (fndecl), TDF_SLIM | local_dump_flags, dump_orig); else print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl)); fprintf (dump_orig, "\n"); dump_end (TDI_original, dump_orig); } /* Dump all nested functions now. */ cgn = cgraph_node (fndecl); for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested) c_genericize (cgn->decl); }
static svn_error_t * open_file(const char *path, void *parent_baton, svn_revnum_t ancestor_revision, apr_pool_t *pool, void **file_baton) { struct dir_baton *pb = parent_baton; struct edit_baton *eb = pb->edit_baton; const char *cmp_path = NULL; svn_revnum_t cmp_rev = SVN_INVALID_REVNUM; /* If the parent directory has explicit comparison path and rev, record the same for this one. */ if (ARE_VALID_COPY_ARGS(pb->cmp_path, pb->cmp_rev)) { cmp_path = svn_relpath_join(pb->cmp_path, svn_relpath_basename(path, pool), pool); cmp_rev = pb->cmp_rev; } SVN_ERR(dump_node(eb, path, svn_node_file, svn_node_action_change, FALSE, cmp_path, cmp_rev, pool)); *file_baton = NULL; /* muhahahaha again */ return SVN_NO_ERROR; }
static svn_error_t * close_directory(void *dir_baton, apr_pool_t *pool) { struct dir_baton *db = dir_baton; struct edit_baton *eb = db->edit_baton; apr_hash_index_t *hi; apr_pool_t *subpool = svn_pool_create(pool); for (hi = apr_hash_first(pool, db->deleted_entries); hi; hi = apr_hash_next(hi)) { const void *key; const char *path; apr_hash_this(hi, &key, NULL, NULL); path = key; svn_pool_clear(subpool); /* By sending 'svn_node_unknown', the Node-kind: header simply won't be written out. No big deal at all, really. The loader shouldn't care. */ SVN_ERR(dump_node(eb, path, svn_node_unknown, svn_node_action_delete, FALSE, NULL, SVN_INVALID_REVNUM, subpool)); } svn_pool_destroy(subpool); return SVN_NO_ERROR; }
static svn_error_t * add_file(const char *path, void *parent_baton, const char *copyfrom_path, svn_revnum_t copyfrom_rev, apr_pool_t *pool, void **file_baton) { struct dir_baton *pb = parent_baton; struct edit_baton *eb = pb->edit_baton; void *val; svn_boolean_t is_copy = FALSE; /* This might be a replacement -- is the path already deleted? */ val = apr_hash_get(pb->deleted_entries, path, APR_HASH_KEY_STRING); /* Detect add-with-history. */ is_copy = ARE_VALID_COPY_ARGS(copyfrom_path, copyfrom_rev); /* Dump the node. */ SVN_ERR(dump_node(eb, path, svn_node_file, val ? svn_node_action_replace : svn_node_action_add, is_copy, is_copy ? copyfrom_path : NULL, is_copy ? copyfrom_rev : SVN_INVALID_REVNUM, pool)); if (val) /* delete the path, it's now been dumped. */ apr_hash_set(pb->deleted_entries, path, APR_HASH_KEY_STRING, NULL); *file_baton = NULL; /* muhahahaha */ return SVN_NO_ERROR; }
void dump_node(const node_t *node, const char *path) { node_t *child; char *path_new; int i; assert (node && path); /* path could point to an empty string but never NULL */ if (!(path_new = (char *)malloc(strlen(path) + 2))) { return; } sprintf(path_new, "%s%c", path, node->c); if (node->cnt) { printf("%s : %d\n", path_new, node->cnt); } for (i = 0; i < AVAILABLE_CHARS; i++) { if (!(child = node->children[i])) { continue; } dump_node(child, path_new); } free(path_new); }
char *store_restart_layout(void) { setlocale(LC_NUMERIC, "C"); yajl_gen gen = yajl_gen_alloc(NULL); dump_node(gen, croot, true); setlocale(LC_NUMERIC, ""); const unsigned char *payload; size_t length; y(get_buf, &payload, &length); /* create a temporary file if one hasn't been specified, or just * resolve the tildes in the specified path */ char *filename; if (config.restart_state_path == NULL) { filename = get_process_filename("restart-state"); if (!filename) return NULL; } else { filename = resolve_tilde(config.restart_state_path); } int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR); if (fd == -1) { perror("open()"); free(filename); return NULL; } size_t written = 0; while (written < length) { int n = write(fd, payload + written, length - written); /* TODO: correct error-handling */ if (n == -1) { perror("write()"); free(filename); close(fd); return NULL; } if (n == 0) { DLOG("write == 0?\n"); free(filename); close(fd); return NULL; } written += n; DLOG("written: %zd of %zd\n", written, length); } close(fd); if (length > 0) { DLOG("layout: %.*s\n", (int)length, payload); } y(free); return filename; }
static void dump_node(struct npr_rbtree_node *n, int depth) { if (n) { dump_node(n->left, depth+1); for (int di=0; di<depth; di++) { printf(" "); } if (n->color == BLACK) { printf("{B, %d,%d}\n", (int)n->key, (int)n->v); } else { printf("{R, %d,%d}\n", (int)n->key, (int)n->v); } dump_node(n->right, depth+1); } }
void dump_trie(Trie *v, int detail) { int i; dump_node(v, detail); for (i = 0; i < v->nchildren; i++) dump_trie(&v->children[i], detail); }
void dump_path(Trie *v, int detail) { int depth = v->depth, i; Trie *path[MAX_DEPTH]; while (v != NULL) { path[v->depth] = v; v = v->parent; } for (i = 0; i < depth; i++) { if (path[i]->nrules <= 16) dump_node(path[i], detail); else dump_node(path[i], 0); } }
/* Print the created AST to stdout, mostly for debugging purposes */ void dump(file_contents contents) { { linked_iter iterator = ll_iter_head(contents.imports); while(ll_iter_has_next(&iterator)) { import_declaration *import = ll_iter_next(&iterator); printf("IMPORT: %s\n", evaluate(import->name)); } } { linked_iter iterator = ll_iter_head(contents.enums); while(ll_iter_has_next(&iterator)) { enum_declaration *dec = ll_iter_next(&iterator); printf("ENUM: %s\n", evaluate(dec->name)); linked_iter items = ll_iter_head(dec->options); while(ll_iter_has_next(&items)) { statement *option = ll_iter_next(&items); printf("\tOPTION: %s\n", evaluate(option->data)); } } } { linked_iter iterator = ll_iter_head(contents.structs); while(ll_iter_has_next(&iterator)) { struct_declaration *current = ll_iter_next(&iterator); printf("STRUCT: %s\n", evaluate(current->name)); linked_iter iterator = ll_iter_head(current->members); while(ll_iter_has_next(&iterator)) { struct_member *member = ll_iter_next(&iterator); printf("\tMEMBER: NAME: %s | TYPE: %s\n", evaluate(member->name), evaluate(member->type)); } } } { linked_iter iterator = ll_iter_head(contents.functions); while(ll_iter_has_next(&iterator)) { func_declaration *current = ll_iter_next(&iterator); printf("FUNC: %s | TYPE : %s\n", evaluate(current->name), evaluate(current->type)); printf("\tPARAMETERS:\n"); dump_node(current->parameters, 2); printf("\tBODY:\n"); dump_node(current->root->children, 2); } } }
static int dump_node(pNode node) { switch(node->type) { case literal: printf("\"%s\"", node->data); break; case symbol: printf("{%s", node->data); if(node->params) { printf("("); dump_atoms(node->params); printf(")"); }; printf("}"); break; case mapping: dump_node(node->params); printf(" > %s", node->data); break; case deref: printf("DEREF("); dump_node(node->params); printf(")"); break; case var_conddef: printf("%s << ", node->data); dump_node(node->params); break; case var_def: printf("%s = ", node->data); dump_node(node->params); break; case code: printf("code:"); dump_code(node->data); break; break; }; };
void yyprint (FILE* outfile, unsigned short toknum, astree* yyvaluep) { if (is_defined_token (toknum)) { dump_node (outfile, yyvaluep); }else { fprintf (outfile, "%s(%d)\n", get_yytname (toknum), toknum); } fflush (NULL); }
void yyprint (FILE *outfile, unsigned short toknum, astree yyvaluep) { fprintf (outfile, "%d=%s)\n%*s(", toknum, get_yytname (toknum), 9, ""); if (is_astree (yyvaluep)) { dump_node (outfile, yyvaluep, 3); }else{ fprintf (outfile, "yyvaluep = %p", (void*) yyvaluep); } fflush (NULL); }
static void dump_astree_rec (FILE* outfile, astree* root, int depth) { if (root == NULL) return; dump_node (outfile, root); fprintf (outfile, "\n"); for (size_t child = 0; child < root->children.size(); ++child) { dump_astree_rec (outfile, root->children[child], depth + 1); } }
static void dump_astree_rec (FILE *outfile, astree root, int depth) { astree child = NULL; if (root == NULL) return; assert (is_astree (root)); //fprintf (outfile, "%*s%s ", depth * 3, "", root->lexinfo); dump_node (outfile, root, depth); fprintf (outfile, "\n"); for (child = root->first; child != NULL; child = child->next) { dump_astree_rec (outfile, child, depth + 1); } }
static void dump_branch ( tree_s *tree, branch_s *branch, unint depth) { key_s *k; unint i; if (!branch) return; dprintk("%sbranch: num keys = %d\n", indent(depth), branch->br_num); dprintk("%sfirst %llx\n", indent(depth), branch->br_first); dump_node(tree, branch->br_first, depth+1); for (k = branch->br_key, i = 0; i < branch->br_num; k++, i++) { dprintk("%s%4lu. %16llx: %llx\n", indent(depth), i, k->k_key, k->k_block); dump_node(tree, k->k_block, depth+1); } }
void dump_branch ( tree_s *tree, branch_s *branch, unint depth) { key_s *k; unint i; if (!branch) return; printf("%sbranch: num keys = %d\n", indent(depth), branch->br_num); printf("%sfirst %p\n", indent(depth), branch->br_first); dump_node(tree, branch->br_first, depth+1); for (k = branch->br_key, i = 0; i < branch->br_num; k++, i++) { printf("%s%4lu. %8x: %p\n", indent(depth), i, k->k_key, k->k_node); dump_node(tree, k->k_node, depth+1); } }
void test_node (void) { UgNode* root; UgNode* node1; UgNode* node2; UgNode* node3; UgNode* node4; puts ("\n--- test_node:"); root = ug_node_new (); node1 = ug_node_new (); node1->data = (void*)(uintptr_t) 1; node2 = ug_node_new (); node2->data = (void*)(uintptr_t) 2; node3 = ug_node_new (); node3->data = (void*)(uintptr_t) 3; node4 = ug_node_new (); node4->data = (void*)(uintptr_t) 4; ug_node_append (root, node3); printf ("ug_node_append (3)\n"); ug_node_prepend (root, node1); printf ("ug_node_prepend (1)\n"); ug_node_insert (root, node3, node2); printf ("ug_node_insert (2) before 3\n"); ug_node_append (root, node4); printf ("ug_node_append (4)\n"); printf ("root.n_children : %d\n", root->n_children); dump_node (root); ug_node_unlink (node2); dump_node (node2); ug_node_free (root); ug_node_free (node1); ug_node_free (node2); ug_node_free (node3); ug_node_free (node4); }
static ssize_t last_job_read(struct file *filp, char __user *buf, size_t bytes, loff_t *off) { struct b2r2_control *cont = filp->f_dentry->d_inode->i_private; struct b2r2_node *node = cont->last_job; int node_count = 0; int i; size_t size; size_t count; loff_t offs = *off; for (; node != NULL; node = node->next) node_count++; size = node_count * DUMPED_NODE_SIZE; if (node_count != cont->prev_node_count) { kfree(cont->last_job_chars); cont->last_job_chars = kzalloc(size, GFP_KERNEL); if (!cont->last_job_chars) return 0; cont->prev_node_count = node_count; } mutex_lock(&cont->last_job_lock); node = cont->last_job; for (i = 0; i < node_count; i++) { BUG_ON(node == NULL); dump_node(cont->last_job_chars + i * DUMPED_NODE_SIZE/sizeof(char), node); node = node->next; } mutex_unlock(&cont->last_job_lock); if (offs > size) return 0; if (offs + bytes > size) count = size - offs; else count = bytes; if (copy_to_user(buf, cont->last_job_chars + offs, count)) return -EFAULT; *off = offs + count; return count; }
void dfont_dump(struct dfont * df) { printf("version = %d\n",df->version); printf("By version : "); struct hash_rect *hr; int version = -1; list_for_each_entry(hr, struct hash_rect, &df->time, time) { if (hr->version != version) { version = hr->version; printf("\nversion %d : ", version); } dump_node(hr); } printf("\n"); printf("By line : \n"); int i; for (i=0;i<df->max_line;i++) { struct font_line *line = &df->line[i]; printf("line (y=%d h=%d space=%d) :",line->start_line, line->height,line->space); list_for_each_entry(hr, struct hash_rect, &line->head, next_char) { printf("%d(%d-%d) ",hr->c,hr->rect.x,hr->rect.x+hr->rect.w-1); } printf("\n"); } printf("By hash : \n"); for (i=0;i<HASH_SIZE;i++) { struct hash_rect *hr = df->hash[i]; if (hr) { printf("%d : ",i); while (hr) { dump_node(hr); hr = hr->next_hash; } printf("\n"); } } }
/* Print an AST node to stdout (recursive) */ void dump_node(linked_list *list, int indentation) { linked_iter iterator = ll_iter_head(list); while(ll_iter_has_next(&iterator)) { for(int i = 0; i < indentation; i++) { printf("\t"); } statement *state = ll_iter_next(&iterator); printf("%s", statement_to_string(state->type)); printf(": %s\n", evaluate(state->data)); if(state->children != NULL) { dump_node(state->children, indentation + 1); } } }
static struct astar_node *astar_path_reverse(struct astar_node *node) { struct astar_node *ret; dump_node(node); /* simple case of only one node in the path */ if (!node->next) return node; node->len = 0; ret = astar_path_reverse_aux(node->next, node); node->next = 0; return ret; }
void dump_db(yadb_t* db) { printf("File: '%s'\n", db->filename); printf("Head: %10p\n", db->head); printf("Tail: %10p\n", db->tail); printf("Size: %10d\n", db->size); node_t* it = _db_begin(db); if (it) { printf("Data: \n\n"); } for (it = _db_begin(db); it != _db_end(db); it = it->next) { dump_node(it); } }
static struct astar_node *astar_path_reverse_aux(struct astar_node *node, struct astar_node *prev) { struct astar_node *ret; dump_node(node); node->len = prev->len + 1; assert(node->len < 1000); /* debug */ if (node->next) ret = astar_path_reverse_aux(node->next, node); else ret = node; node->next = prev; return ret; }
static int delete_node(u64 n1, u64 n2, u64 n3, u64 n4) { int result; dump_node(0, n1, n2, n3, n4, 0, 0); result = lv1_delete_repository_node(n1, n2, n3, n4); if (result) { pr_devel("%s:%d: lv1_delete_repository_node failed: %s\n", __func__, __LINE__, ps3_result(result)); return -ENOENT; } return 0; }