bool cilk_recognize_spawn (tree exp, tree *exp0) { bool spawn_found = false; if (TREE_CODE (exp) == CILK_SPAWN_STMT) { /* Remove the CALL_EXPR from CILK_SPAWN_STMT wrapper. */ exp = CILK_SPAWN_FN (exp); walk_tree (exp0, unwrap_cilk_spawn_stmt, NULL, NULL); spawn_found = true; } /* _Cilk_spawn can't be wrapped in expression such as PLUS_EXPR. */ else if (contains_cilk_spawn_stmt (exp)) { location_t loc = EXPR_LOCATION (exp); if (loc == UNKNOWN_LOCATION) { tree stmt = walk_tree (&exp, contains_cilk_spawn_stmt_walker, NULL, NULL); gcc_assert (stmt != NULL_TREE); loc = EXPR_LOCATION (stmt); } error_at (loc, "invalid use of %<_Cilk_spawn%>"); } return spawn_found; }
// returns a pointer to a node to abort walking the tree // returns NULL to continue walking the tree // return value is driven proc node_t *walk_tree(node_t *pNode, node_t *(*pProc)(node_t *pNode)) { node_t* left = NULL; node_t* right = NULL; node_t* result = NULL; // pProc may be destructive // cache left and right if (NULL != pNode) { left = pNode->left; right = pNode->right; } // walk left if possible and not done if (NULL != left && NULL == result) { result = walk_tree(left, pProc); } // proc current node if possible and not done if (NULL != pProc && NULL == result) { result = pProc(pNode); } // walk right if possible and not done if (NULL != right && NULL == result) { result = walk_tree(right, pProc); } return result; }
tree replace_invariant_exprs (tree *node) { size_t ix = 0; tree node_list = NULL_TREE; tree t = NULL_TREE, new_var = NULL_TREE, new_node; struct inv_list data; data.list_values = NULL; data.replacement = NULL; data.additional_tcodes = NULL; walk_tree (node, find_inv_trees, (void *)&data, NULL); if (vec_safe_length (data.list_values)) { node_list = push_stmt_list (); for (ix = 0; vec_safe_iterate (data.list_values, ix, &t); ix++) { new_var = build_decl (EXPR_LOCATION (t), VAR_DECL, NULL_TREE, TREE_TYPE (t)); gcc_assert (new_var != NULL_TREE && new_var != error_mark_node); new_node = build2 (MODIFY_EXPR, TREE_TYPE (t), new_var, t); add_stmt (new_node); vec_safe_push (data.replacement, new_var); } walk_tree (node, replace_inv_trees, (void *)&data, NULL); node_list = pop_stmt_list (node_list); } return node_list; }
void find_column_headers(IAccessible *pAccessible, char ***pHeaderNames, long *pColumns) { long columns = 0 ; walk_tree(pAccessible, NULL, &columns) ; char **pHeaders = (char **)malloc(sizeof(char *) * columns) ; walk_tree(pAccessible, pHeaders, &columns) ; *pHeaderNames = pHeaders ; *pColumns = columns ; }
/* * Tree walking with acending key order */ void walk_tree(int fd_in, int fd_out, compact_header_t * tree) { if (tree->left != NULL) { walk_tree(fd_in, fd_out, tree->left); } write_node(fd_in, fd_out, tree, io_buf, IO_BUFFER_SZ); if (tree->right != NULL) { walk_tree(fd_in, fd_out, tree->right); } free(tree); }
int next_file(const char *arg, seq_t seq) { char *line; int errors = 0; if (strcmp(arg, "-") == 0) { while ((line = next_line(stdin))) errors = walk_tree(line, seq); } else { errors = walk_tree(arg, seq); } return errors ? 1 : 0; }
int main (int argc, char *argv[]) { char *dir = "."; tick_t start; tick_t finish; tick_t total; if (argc > 1) dir = argv[1]; NumFiles = 0; start = nsecs(); nftw_walk_tree(dir); finish = nsecs(); total = finish - start; printf("%lld nsecs %d\n", total, NumFiles); NumFiles = 0; start = nsecs(); walk_dir(dir, donothing, NULL, 0); finish = nsecs(); total = finish - start; printf("%lld nsecs %d\n", total, NumFiles); NumFiles = 0; start = nsecs(); walk_tree(dir, prfile, NULL); finish = nsecs(); total = finish - start; printf("%lld nsecs %d\n", total, NumFiles); return 0; }
static void analyze_variable (struct varpool_node *vnode) { tree global = vnode->decl; walk_tree (&DECL_INITIAL (global), scan_for_static_refs, NULL, visited_nodes); }
static void analyze_function (struct cgraph_node *fn) { ipa_reference_vars_info_t info = xcalloc (1, sizeof (struct ipa_reference_vars_info_d)); ipa_reference_local_vars_info_t l = xcalloc (1, sizeof (struct ipa_reference_local_vars_info_d)); tree decl = fn->decl; /* Add the info to the tree's annotation. */ get_function_ann (fn->decl)->reference_vars_info = info; info->local = l; l->statics_read = BITMAP_ALLOC (&ipa_obstack); l->statics_written = BITMAP_ALLOC (&ipa_obstack); if (dump_file) fprintf (dump_file, "\n local analysis of %s\n", cgraph_node_name (fn)); { struct function *this_cfun = DECL_STRUCT_FUNCTION (decl); basic_block this_block; FOR_EACH_BB_FN (this_block, this_cfun) { block_stmt_iterator bsi; for (bsi = bsi_start (this_block); !bsi_end_p (bsi); bsi_next (&bsi)) walk_tree (bsi_stmt_ptr (bsi), scan_for_static_refs, fn, visited_nodes); } }
/* Redirect references. */ FOR_EACH_VEC_ELT (references_to_redirect, i, ref) { if (ref->use == IPA_REF_ADDR) { struct walk_stmt_info wi; memset (&wi, 0, sizeof (wi)); wi.info = (void *)node->function_version (); if (dyn_cast<varpool_node *> (ref->referring)) { hash_set<tree> visited_nodes; walk_tree (&DECL_INITIAL (ref->referring->decl), replace_function_decl, &wi, &visited_nodes); } else { gimple_stmt_iterator it = gsi_for_stmt (ref->stmt); if (ref->referring->decl != resolver_decl) walk_gimple_stmt (&it, NULL, replace_function_decl, &wi); } symtab_node *source = ref->referring; ref->remove_reference (); source->create_reference (inode, IPA_REF_ADDR); } else if (ref->use == IPA_REF_ALIAS) { symtab_node *source = ref->referring; ref->remove_reference (); source->create_reference (inode, IPA_REF_ALIAS); source->add_to_same_comdat_group (inode); } else gcc_unreachable (); }
static gboolean snippets_load_finished_lcb(gpointer data) { xmlDocPtr doc = (xmlDocPtr)data; xmlNodePtr cur=NULL; DEBUG_SIG("snippets_load_finished_lcb, priority=%d\n",G_PRIORITY_LOW); DEBUG_MSG("snippets_load_finished_lcb, doc=%p, starting to load xml data into treestore\n", doc); if (doc) { cur = xmlDocGetRootElement(doc); if (cur) { if (xmlStrEqual(cur->name, (const xmlChar *) "snippets")) { snippets_v.doc = doc; walk_tree(cur, NULL); snippets_rebuild_accelerators(); DEBUG_MSG("snippets_load_finished_lcb, finished walking tree\n"); return FALSE; } } xmlFreeDoc(doc); doc = NULL; } if (doc == NULL) { snippets_v.doc = xmlNewDoc((const xmlChar *)"1.0"); cur = xmlNewDocNode(snippets_v.doc,NULL, (const xmlChar *)"snippets",NULL); xmlDocSetRootElement(snippets_v.doc, cur); /* DEBUG_MSG("snippets_load_finished_lcb, loading from cmenu %p and %p\n",main_v->props.cmenu_insert, main_v->props.cmenu_replace); */ /* now check if there is a custom menu configuration. If there is one, parse it and build a xml tree */ /* if (snippets_convert_cmenu(cur)) { walk_tree(cur, NULL); }*/ } DEBUG_MSG("snippets_load_finished_lcb, finished empty tree\n"); return FALSE; }
void snippets_fill_tree_item_from_node(GtkTreeIter *iter, xmlNodePtr node) { gchar *title; gboolean recursive=FALSE; GdkPixbuf* pixmap=NULL; DEBUG_MSG("snippets_fill_tree_item_from_node, got node with type %s\n",node->name); title = (gchar *)xmlGetProp(node, (const xmlChar *)"title"); DEBUG_MSG("snippets_fill_tree_item_from_node, node has title %s\n",title); if ((xmlStrEqual(node->name, (const xmlChar *)"branch"))) { pixmap = NULL; recursive = TRUE; } else /*if ((xmlStrEqual(cur->name, (const xmlChar *)"leaf")))*/ { xmlChar *type; type = xmlGetProp(node, (const xmlChar *)"type"); if (xmlStrEqual(type, (const xmlChar *)"insert")) { pixmap = gdk_pixbuf_new_from_inline(-1, pixmap_insert, FALSE, NULL); } else if (xmlStrEqual(type, (const xmlChar *)"snr")) { pixmap = gdk_pixbuf_new_from_inline(-1, pixmap_snr, FALSE, NULL); } xmlFree(type); } gtk_tree_store_set(snippets_v.store, iter, PIXMAP_COLUMN, pixmap, TITLE_COLUMN, title,NODE_COLUMN, node,-1); if (pixmap) { g_object_unref(pixmap); } xmlFree(title); if (recursive) { walk_tree(node, iter); } }
int next_file(const char *arg, seq_t seq) { char *line; int errors = 0; if (strcmp(arg, "-") == 0) { while ((line = next_line(stdin))) errors = walk_tree(line, walk_flags, 0, do_set, seq); if (!feof(stdin)) { fprintf(stderr, _("%s: Standard input: %s\n"), progname, strerror(errno)); errors = 1; } } else { errors = walk_tree(arg, walk_flags, 0, do_set, seq); } return errors ? 1 : 0; }
static int walk_tree(int path_len, watch_node* parent, bool recursive, array* mounts) { for (int j=0; j<array_size(mounts); j++) { char* mount = array_get(mounts, j); if (strncmp(path_buf, mount, strlen(mount)) == 0) { userlog(LOG_DEBUG, "watch path '%s' crossed mount point '%s' - skipping", path_buf, mount); return ERR_IGNORE; } } DIR* dir = NULL; if (recursive) { if ((dir = opendir(path_buf)) == NULL) { if (errno == EACCES || errno == ENOENT || errno == ENOTDIR) { userlog(LOG_DEBUG, "opendir(%s): %d", path_buf, errno); return ERR_IGNORE; } else { userlog(LOG_ERR, "opendir(%s): %s", path_buf, strerror(errno)); return ERR_CONTINUE; } } } int id = add_watch(path_len, parent); if (dir == NULL) { return id; } else if (id < 0) { closedir(dir); return id; } path_buf[path_len] = '/'; struct dirent* entry; while ((entry = readdir(dir)) != NULL) { if (entry->d_type != DT_DIR || strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) { continue; } int name_len = strlen(entry->d_name); memcpy(path_buf + path_len + 1, entry->d_name, name_len + 1); int subdir_id = walk_tree(path_len + 1 + name_len, table_get(watches, id), recursive, mounts); if (subdir_id < 0 && subdir_id != ERR_IGNORE) { rm_watch(id, true); id = subdir_id; break; } } closedir(dir); return id; }
int walk_tree(pTree *tree, struct pqNode **ps, int index) { if (tree == NULL) return index; fprintf(err, "( "); index = walk_tree(tree->pLeft, ps, index); struct pqNode *l; for (l = tree->cell.list; l != NULL; l = l->neighbor) { //ps[index++] = l; fprintf(err, "%.2f ", l->r[0]); } index = walk_tree(tree->pRight, ps, index); fprintf(err, ") "); return index; }
int walk_tree(pTree *tree, struct pqNode **ps, int index) { if (tree == NULL) return index; fprintf(err, "( "); index = walk_tree(tree->pLeft, ps, index); if (tree->pLeft == NULL && tree->pRight == NULL) { int i; for (i=tree->iLower; i <= tree->iUpper; i++) fprintf(err, "%.2f ", ps[i]->r[0]); } index = walk_tree(tree->pRight, ps, index); fprintf(err, ") \n"); return index; }
static void analyze_variable (struct cgraph_varpool_node *vnode) { tree global = vnode->decl; if (TREE_CODE (global) == VAR_DECL) { if (DECL_INITIAL (global)) walk_tree (&DECL_INITIAL (global), scan_for_static_refs, NULL, visited_nodes); } else gcc_unreachable (); }
void walk_tree(GMenuTreeDirectory *root) { GSList *list = gmenu_tree_directory_get_contents(root); while (list) { const char *category; const char *application; const char *exec; switch (gmenu_tree_item_get_type (list->data)) { case GMENU_TREE_ITEM_DIRECTORY: category = gmenu_tree_directory_get_name (list->data); if (category) { printf("<menu name=\"%s\">\n", category); free((void *)category); } GMenuTreeDirectory *dir = (GMenuTreeDirectory*)list->data; walk_tree(dir); printf("</menu>\n"); break; case GMENU_TREE_ITEM_ENTRY: if (!gmenu_tree_entry_get_is_excluded(list->data) && !gmenu_tree_entry_get_is_nodisplay(list->data)) { application = gmenu_tree_entry_get_name(list->data); if (application) { exec = filter(gmenu_tree_entry_get_exec(list->data)); if (exec) { if (gmenu_tree_entry_get_launch_in_terminal(list->data)) { printf("<command name=\"%s\" execute=\"xterm -title '%s' -e '%s' &\" />\n", application, application, exec); } else { printf("<command name=\"%s\" execute=\"menuorg-execute-wrapper %s '%s'\" />\n", application, application, exec); } free((void *)application); } } } break; default: break; } list = g_slist_next(list); } }
void record_references_in_initializer (tree decl, bool only_vars) { varpool_node *node = varpool_node::get_create (decl); hash_set<tree> visited_nodes; record_reference_ctx ctx = {false, NULL}; ctx.varpool_node = node; ctx.only_vars = only_vars; walk_tree (&DECL_INITIAL (decl), record_reference, &ctx, &visited_nodes); }
static int walk_tree(const char* path, watch_node* parent, array* ignores) { if (is_ignored(path, ignores)) { return ERR_IGNORE; } DIR* dir = opendir(path); if (dir == NULL) { if (errno == EACCES) { return ERR_IGNORE; } else if (errno == ENOTDIR) { // flat root return add_watch(path, parent); } userlog(LOG_ERR, "opendir(%s): %s", path, strerror(errno)); return ERR_CONTINUE; } int id = add_watch(path, parent); if (id < 0) { closedir(dir); return id; } struct dirent* entry; char subdir[PATH_MAX]; strcpy(subdir, path); if (subdir[strlen(subdir) - 1] != '/') { strcat(subdir, "/"); } char* p = subdir + strlen(subdir); while ((entry = readdir(dir)) != NULL) { if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) { continue; } strcpy(p, entry->d_name); if (!is_directory(entry, subdir)) { continue; } int subdir_id = walk_tree(subdir, table_get(watches, id), ignores); if (subdir_id < 0 && subdir_id != ERR_IGNORE) { rm_watch(id, true); id = subdir_id; break; } } closedir(dir); return id; }
static Namfun_t *clone_tree(Namval_t *np, Namval_t *mp, int flags, Namfun_t *fp){ Namfun_t *dp; if ((flags&NV_MOVE) && nv_type(np)) return(fp); dp = nv_clone_disc(fp,flags); if((flags&NV_COMVAR) && !(flags&NV_RAW)) { walk_tree(np,mp,flags); if((flags&NV_MOVE) && !(fp->nofree&1)) free((void*)fp); } return(dp); }
static bool recognize_spawn (tree exp, tree *exp0) { bool spawn_found = false; if (TREE_CODE (exp) == CILK_SPAWN_STMT) { /* Remove the CALL_EXPR from CILK_SPAWN_STMT wrapper. */ exp = CILK_SPAWN_FN (exp); walk_tree (exp0, unwrap_cilk_spawn_stmt, NULL, NULL); spawn_found = true; } return spawn_found; }
void record_references_in_initializer (tree decl, bool only_vars) { struct pointer_set_t *visited_nodes = pointer_set_create (); varpool_node *node = varpool_node_for_decl (decl); struct record_reference_ctx ctx = {false, NULL}; ctx.varpool_node = node; ctx.only_vars = only_vars; walk_tree (&DECL_INITIAL (decl), record_reference, &ctx, visited_nodes); pointer_set_destroy (visited_nodes); }
void reload_tree_from_doc(void) { if (snippets_v.doc) { xmlNodePtr cur = xmlDocGetRootElement(snippets_v.doc); if (cur) { if (xmlStrEqual(cur->name, (const xmlChar *) "snippets")) { /* the document is correct, first empty the treestore */ gtk_tree_store_clear(snippets_v.store); /* now reload the tree */ walk_tree(cur, NULL); } } } }
void main(int argc, char *argv[]) { GMenuTree *tree = NULL; GMenuTreeDirectory *directory = NULL; GMenuTreeEntry *entry = NULL; const char *name = NULL; gtk_set_locale (); tree = gmenu_tree_lookup ("lxde-applications.menu", GMENU_TREE_FLAGS_NONE); directory = gmenu_tree_get_root_directory(tree); walk_tree(directory); }
void cp_genericize (tree fndecl) { tree t; struct pointer_set_t *p_set; /* Fix up the types of parms passed by invisible reference. */ for (t = DECL_ARGUMENTS (fndecl); t; t = TREE_CHAIN (t)) if (TREE_ADDRESSABLE (TREE_TYPE (t))) { /* If a function's arguments are copied to create a thunk, then DECL_BY_REFERENCE will be set -- but the type of the argument will be a pointer type, so we will never get here. */ gcc_assert (!DECL_BY_REFERENCE (t)); gcc_assert (DECL_ARG_TYPE (t) != TREE_TYPE (t)); TREE_TYPE (t) = DECL_ARG_TYPE (t); DECL_BY_REFERENCE (t) = 1; TREE_ADDRESSABLE (t) = 0; relayout_decl (t); } /* Do the same for the return value. */ if (TREE_ADDRESSABLE (TREE_TYPE (DECL_RESULT (fndecl)))) { t = DECL_RESULT (fndecl); TREE_TYPE (t) = build_reference_type (TREE_TYPE (t)); DECL_BY_REFERENCE (t) = 1; TREE_ADDRESSABLE (t) = 0; relayout_decl (t); } /* If we're a clone, the body is already GIMPLE. */ if (DECL_CLONED_FUNCTION_P (fndecl)) return; /* We do want to see every occurrence of the parms, so we can't just use walk_tree's hash functionality. */ p_set = pointer_set_create (); walk_tree (&DECL_SAVED_TREE (fndecl), cp_genericize_r, p_set, NULL); pointer_set_destroy (p_set); /* Do everything else. */ c_genericize (fndecl); gcc_assert (bc_label[bc_break] == NULL); gcc_assert (bc_label[bc_continue] == NULL); }
static bool recognize_spawn (tree exp, tree *exp0) { bool spawn_found = false; if (TREE_CODE (exp) == CILK_SPAWN_STMT) { /* Remove the CALL_EXPR from CILK_SPAWN_STMT wrapper. */ exp = CILK_SPAWN_FN (exp); walk_tree (exp0, unwrap_cilk_spawn_stmt, NULL, NULL); spawn_found = true; } /* _Cilk_spawn can't be wrapped in expression such as PLUS_EXPR. */ else if (contains_cilk_spawn_stmt (exp)) error_at (EXPR_LOCATION (exp), "invalid use of %<_Cilk_spawn%>"); return spawn_found; }
/* * Generates the HBA logical ap_id from physical ap_id. */ scfga_ret_t make_hba_logid(const char *hba_phys, char **hba_logpp, int *l_errnop) { walkarg_t u; pathm_t pmt = {NULL}; scfga_ret_t ret; if (*hba_logpp != NULL) { return (SCFGA_ERR); } /* A devlink for the HBA may or may not exist */ if (get_hba_devlink(hba_phys, hba_logpp, l_errnop) == SCFGA_OK) { assert(*hba_logpp != NULL); return (SCFGA_OK); } /* * No devlink based logical ap_id. * Try driver name and instance number. */ u.minor_args.nodetype = DDI_NT_SCSI_ATTACHMENT_POINT; u.minor_args.fcn = drv_to_hba_logid; pmt.phys = (char *)hba_phys; pmt.ret = SCFGA_APID_NOEXIST; errno = 0; ret = walk_tree(pmt.phys, &pmt, DINFOMINOR | DINFOPROP, &u, SCFGA_WALK_MINOR, &pmt.l_errno); if (ret == SCFGA_OK && (ret = pmt.ret) == SCFGA_OK) { assert(pmt.log != NULL); *hba_logpp = pmt.log; return (SCFGA_OK); } /* failed to create logical ap_id */ if (pmt.log != NULL) { S_FREE(pmt.log); } *l_errnop = pmt.l_errno; return (ret); }
static tree ubsan_walk_array_refs_r (tree *tp, int *walk_subtrees, void *data) { hash_set<tree> *pset = (hash_set<tree> *) data; if (TREE_CODE (*tp) == BIND_EXPR) { /* Since walk_tree doesn't call the callback function on the decls in BIND_EXPR_VARS, we have to walk them manually, so we can avoid instrumenting DECL_INITIAL of TREE_STATIC vars. */ *walk_subtrees = 0; for (tree decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl)) { if (TREE_STATIC (decl)) continue; walk_tree (&DECL_INITIAL (decl), ubsan_walk_array_refs_r, pset, pset); walk_tree (&DECL_SIZE (decl), ubsan_walk_array_refs_r, pset, pset); walk_tree (&DECL_SIZE_UNIT (decl), ubsan_walk_array_refs_r, pset, pset); } walk_tree (&BIND_EXPR_BODY (*tp), ubsan_walk_array_refs_r, pset, pset); } else if (TREE_CODE (*tp) == ADDR_EXPR && TREE_CODE (TREE_OPERAND (*tp, 0)) == ARRAY_REF) { ubsan_maybe_instrument_array_ref (&TREE_OPERAND (*tp, 0), true); /* Make sure ubsan_maybe_instrument_array_ref is not called again on the ARRAY_REF, the above call might not instrument anything as the index might be constant or masked, so ensure it is not walked again and walk its subtrees manually. */ tree aref = TREE_OPERAND (*tp, 0); pset->add (aref); *walk_subtrees = 0; walk_tree (&TREE_OPERAND (aref, 0), ubsan_walk_array_refs_r, pset, pset); walk_tree (&TREE_OPERAND (aref, 1), ubsan_walk_array_refs_r, pset, pset); walk_tree (&TREE_OPERAND (aref, 2), ubsan_walk_array_refs_r, pset, pset); walk_tree (&TREE_OPERAND (aref, 3), ubsan_walk_array_refs_r, pset, pset); } else if (TREE_CODE (*tp) == ARRAY_REF) ubsan_maybe_instrument_array_ref (tp, false); return NULL_TREE; }
int main(int argc, char *argv[]) { xmlDoc *doc = NULL; xmlNode *root_element = NULL; /* * this initialize the library and check potential ABI mismatches * between the version it was compiled for and the actual shared * library used. */ LIBXML_TEST_VERSION /*parse the file and get the DOM */ doc = xmlReadFile("test.html", NULL, 0); if (doc == NULL) { printf("error: could not parse file %s\n", argv[1]); } /*Get the root element node */ root_element = xmlDocGetRootElement(doc); OMS_PAGE *p = oms_new_page(); oms_add_string(p, "1/http://ya.ru/"); oms_add_authcode(p, "c37c206d2c235978d086b64c39a2fc17df68dbdd5dc04dd8b199177f95be6181"); oms_add_authprefix(p, "t19-12"); oms_add_style(p, 0x02000002); walk_tree(root_element, p); oms_finalize_page(p); oms_free_page(p); /*free the document */ xmlFreeDoc(doc); /* *Free the global variables that may *have been allocated by the parser. */ xmlCleanupParser(); return 0; }