////////////////////////////////////////////////////////////////////////// // parse_tree ////////////////////////////////////////////////////////////////////////// void parse_tree(token_vector &tokens, token_vector &tree, TokenType until) { while(! tokens.empty()) { token_ptr token = tokens[0] ; tokens.erase(tokens.begin()) ; if (token->gettype() == TOKEN_TYPE_FOR) { token_vector children ; parse_tree(tokens, children, TOKEN_TYPE_ENDFOR) ; token->set_children(children) ; } else if (token->gettype() == TOKEN_TYPE_IF) { token_vector children ; parse_tree(tokens, children, TOKEN_TYPE_ENDIF) ; token->set_children(children) ; } else if (token->gettype() == until) { return ; } tree.push_back(token) ; } }
static int reset_tree(struct tree *tree, const struct checkout_opts *o, int worktree, int *writeout_error) { struct unpack_trees_options opts; struct tree_desc tree_desc; memset(&opts, 0, sizeof(opts)); opts.head_idx = -1; opts.update = worktree; opts.skip_unmerged = !worktree; opts.reset = 1; opts.merge = 1; opts.fn = oneway_merge; opts.verbose_update = o->show_progress; opts.src_index = &the_index; opts.dst_index = &the_index; parse_tree(tree); init_tree_desc(&tree_desc, tree->buffer, tree->size); switch (unpack_trees(1, &tree_desc, &opts)) { case -2: *writeout_error = 1; /* * We return 0 nevertheless, as the index is all right * and more importantly we have made best efforts to * update paths in the work tree, and we cannot revert * them. */ /* fallthrough */ case 0: return 0; default: return 128; } }
static int fsck_walk_tree(struct tree *tree, fsck_walk_func walk, void *data) { struct tree_desc desc; struct name_entry entry; int res = 0; if (parse_tree(tree)) return -1; init_tree_desc(&desc, tree->buffer, tree->size); while (tree_entry(&desc, &entry)) { int result; if (S_ISGITLINK(entry.mode)) continue; if (S_ISDIR(entry.mode)) result = walk(&lookup_tree(entry.sha1)->object, OBJ_TREE, data); else if (S_ISREG(entry.mode) || S_ISLNK(entry.mode)) result = walk(&lookup_blob(entry.sha1)->object, OBJ_BLOB, data); else { result = error("in tree %s: entry %s has bad mode %.6o\n", sha1_to_hex(tree->object.sha1), entry.path, entry.mode); } if (result < 0) return result; if (!res) res = result; } return res; }
int main(int argc, char *argv[]) { struct rooted_tree *tree; struct parameters params; static struct rooted_tree * (*process_tree)(struct rooted_tree *, set_t *); params = get_params(argc, argv); switch (params.mode) { case PRUNE_DIRECT: process_tree = process_tree_direct; break; case PRUNE_REVERSE: process_tree = process_tree_reverse; break; default: assert (0); } while (NULL != (tree = parse_tree())) { tree = process_tree(tree, params.prune_labels); dump_newick(tree->root); destroy_all_rnodes(NULL); destroy_tree(tree); } destroy_set(params.prune_labels); return 0; }
static void create_base_index(const struct commit *current_head) { struct tree *tree; struct unpack_trees_options opts; struct tree_desc t; if (!current_head) { discard_cache(); return; } memset(&opts, 0, sizeof(opts)); opts.head_idx = 1; opts.index_only = 1; opts.merge = 1; opts.src_index = &the_index; opts.dst_index = &the_index; opts.fn = oneway_merge; tree = parse_tree_indirect(current_head->object.sha1); if (!tree) die(_("failed to unpack HEAD tree object")); parse_tree(tree); init_tree_desc(&t, tree->buffer, tree->size); if (unpack_trees(1, &t, &opts)) exit(128); /* We've already reported the error, finish dying */ }
struct object *parse_object(unsigned char *sha1) { unsigned long mapsize; void *map = map_sha1_file(sha1, &mapsize); if (map) { char type[100]; unsigned long size; void *buffer = unpack_sha1_file(map, mapsize, type, &size); if (!buffer) return NULL; if (check_sha1_signature(sha1, buffer, size, type) < 0) printf("sha1 mismatch %s\n", sha1_to_hex(sha1)); munmap(map, mapsize); if (!strcmp(type, "blob")) { struct blob *ret = lookup_blob(sha1); parse_blob(ret); return &ret->object; } else if (!strcmp(type, "tree")) { struct tree *ret = lookup_tree(sha1); parse_tree(ret); return &ret->object; } else if (!strcmp(type, "commit")) { struct commit *ret = lookup_commit(sha1); parse_commit(ret); return &ret->object; } else if (!strcmp(type, "tag")) { struct tag *ret = lookup_tag(sha1); parse_tag(ret); return &ret->object; } else { return NULL; } } return NULL; }
int main(int argc, char *argv[]) { struct rooted_tree *tree; struct hash *rename_map; struct parameters params; params = get_params(argc, argv); rename_map = read_map(params.map_filename); while (NULL != (tree = parse_tree())) { process_tree(tree, rename_map, params); destroy_tree(tree, DONT_FREE_NODE_DATA); } struct llist *keys = hash_keys(rename_map); if (NULL == keys) { perror(NULL); exit(EXIT_FAILURE); } struct list_elem *e; for (e = keys->head; NULL != e; e = e->next) { char *key = (char *) e->data; char *val = hash_get(rename_map, key); free(val); } destroy_llist(keys); destroy_hash(rename_map); return 0; }
static int checkout(void) { unsigned char sha1[20]; char *head; struct lock_file *lock_file; struct unpack_trees_options opts; struct tree *tree; struct tree_desc t; int err = 0, fd; if (option_no_checkout) return 0; head = resolve_refdup("HEAD", sha1, 1, NULL); if (!head) { warning(_("remote HEAD refers to nonexistent ref, " "unable to checkout.\n")); return 0; } if (!strcmp(head, "HEAD")) { if (advice_detached_head) detach_advice(sha1_to_hex(sha1)); } else { if (prefixcmp(head, "refs/heads/")) die(_("HEAD not found below refs/heads!")); } free(head); /* We need to be in the new work tree for the checkout */ setup_work_tree(); lock_file = xcalloc(1, sizeof(struct lock_file)); fd = hold_locked_index(lock_file, 1); memset(&opts, 0, sizeof opts); opts.update = 1; opts.merge = 1; opts.fn = oneway_merge; opts.verbose_update = (option_verbosity >= 0); opts.src_index = &the_index; opts.dst_index = &the_index; tree = parse_tree_indirect(sha1); parse_tree(tree); init_tree_desc(&t, tree->buffer, tree->size); if (unpack_trees(1, &t, &opts) < 0) die(_("unable to checkout working tree")); if (write_cache(fd, active_cache, active_nr) || commit_locked_index(lock_file)) die(_("unable to write new index file")); err |= run_hook(NULL, "post-checkout", sha1_to_hex(null_sha1), sha1_to_hex(sha1), "1", NULL); if (!err && option_recursive) err = run_command_v_opt(argv_submodule, RUN_GIT_CMD); return err; }
static void prime_cache_tree_rec(struct cache_tree *it, struct tree *tree) { struct tree_desc desc; struct name_entry entry; int cnt; hashcpy(it->sha1, tree->object.sha1); init_tree_desc(&desc, tree->buffer, tree->size); cnt = 0; while (tree_entry(&desc, &entry)) { if (!S_ISDIR(entry.mode)) cnt++; else { struct cache_tree_sub *sub; struct tree *subtree = lookup_tree(entry.sha1); if (!subtree->object.parsed) parse_tree(subtree); sub = cache_tree_sub(it, entry.path); sub->cache_tree = cache_tree(); prime_cache_tree_rec(sub->cache_tree, subtree); cnt += sub->cache_tree->entry_count; } } it->entry_count = cnt; }
static int process_tree(struct walker *walker, struct tree *tree) { struct tree_desc desc; struct name_entry entry; if (parse_tree(tree)) return -1; init_tree_desc(&desc, tree->buffer, tree->size); while (tree_entry(&desc, &entry)) { struct object *obj = NULL; /* submodule commits are not stored in the superproject */ if (S_ISGITLINK(entry.mode)) continue; if (S_ISDIR(entry.mode)) { struct tree *tree = lookup_tree(entry.sha1); if (tree) obj = &tree->object; } else { struct blob *blob = lookup_blob(entry.sha1); if (blob) obj = &blob->object; } if (!obj || process(walker, obj)) return -1; } free(tree->buffer); tree->buffer = NULL; tree->size = 0; tree->object.parsed = 0; return 0; }
static int read_tree_trivial(unsigned char *common, unsigned char *head, unsigned char *one) { int i, nr_trees = 0; struct tree *trees[MAX_UNPACK_TREES]; struct tree_desc t[MAX_UNPACK_TREES]; struct unpack_trees_options opts; memset(&opts, 0, sizeof(opts)); opts.head_idx = 2; opts.src_index = &the_index; opts.dst_index = &the_index; opts.update = 1; opts.verbose_update = 1; opts.trivial_merges_only = 1; opts.merge = 1; trees[nr_trees] = parse_tree_indirect(common); if (!trees[nr_trees++]) return -1; trees[nr_trees] = parse_tree_indirect(head); if (!trees[nr_trees++]) return -1; trees[nr_trees] = parse_tree_indirect(one); if (!trees[nr_trees++]) return -1; opts.fn = threeway_merge; cache_tree_free(&active_cache_tree); for (i = 0; i < nr_trees; i++) { parse_tree(trees[i]); init_tree_desc(t+i, trees[i]->buffer, trees[i]->size); } if (unpack_trees(nr_trees, t, &opts)) return -1; return 0; }
void test_parse(cstring_t s) { int num_lexemes, size_lexemes; LEXEME* lexemes = lex_str(s, &num_lexemes, &size_lexemes); int ender; LexTree* tree = parse_tree(lexemes, num_lexemes, &ender); //printLexTree(tree, 0); JSON* j = parse(tree); print_json(j); }
void solid_repl() { size_t n = 256; char *buffer = (char *) malloc(sizeof(char) * n); solid_vm *vm = make_solid_vm(); set_namespace(get_current_namespace(vm), solid_str("compile"), define_c_function(solid_compile)); set_namespace(get_current_namespace(vm), solid_str("import"), define_c_function(solid_import)); while (printf("%s", "solid> "), getline(&buffer, &n, stdin) != -1) { solid_object *curexpr = parse_tree(parse_expr(buffer)); solid_call_func(vm, curexpr); push_stack(vm, vm->regs[255]); solid_print(vm); } }
////////////////////////////////////////////////////////////////////////// // parse ////////////////////////////////////////////////////////////////////////// wstring parse(wstring templ_text, data_map &data) { token_vector tokens ; tokenize(templ_text, tokens) ; token_vector tree ; parse_tree(tokens, tree) ; std::vector<wstring> nodes ; for (size_t i = 0 ; i < tree.size() ; ++i) { nodes.push_back(tree[i]->gettext(data)); } return boost::join(nodes, L"") ; }
int checkout_fast_forward(const unsigned char *head, const unsigned char *remote, int overwrite_ignore) { struct tree *trees[MAX_UNPACK_TREES]; struct unpack_trees_options opts; struct tree_desc t[MAX_UNPACK_TREES]; int i, nr_trees = 0; struct dir_struct dir; struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file)); refresh_cache(REFRESH_QUIET); hold_locked_index(lock_file, 1); memset(&trees, 0, sizeof(trees)); memset(&opts, 0, sizeof(opts)); memset(&t, 0, sizeof(t)); if (overwrite_ignore) { memset(&dir, 0, sizeof(dir)); dir.flags |= DIR_SHOW_IGNORED; setup_standard_excludes(&dir); opts.dir = &dir; } opts.head_idx = 1; opts.src_index = &the_index; opts.dst_index = &the_index; opts.update = 1; opts.verbose_update = 1; opts.merge = 1; opts.fn = twoway_merge; setup_unpack_trees_porcelain(&opts, "merge"); trees[nr_trees] = parse_tree_indirect(head); if (!trees[nr_trees++]) return -1; trees[nr_trees] = parse_tree_indirect(remote); if (!trees[nr_trees++]) return -1; for (i = 0; i < nr_trees; i++) { parse_tree(trees[i]); init_tree_desc(t+i, trees[i]->buffer, trees[i]->size); } if (unpack_trees(nr_trees, t, &opts)) return -1; if (write_locked_index(&the_index, lock_file, COMMIT_LOCK)) die(_("unable to write new index file")); return 0; }
int main(int argc, char *argv[]) { if (argc > 1) { solid_object *mainfunc = parse_tree(parse_file(argv[1])); solid_vm *vm = make_solid_vm(); set_namespace(get_current_namespace(vm), solid_str("compile"), define_c_function(solid_compile)); set_namespace(get_current_namespace(vm), solid_str("import"), define_c_function(solid_import)); solid_call_func(vm, mainfunc); } else { solid_repl(); } return 0; }
int main(int argc, char *argv[]) { struct rooted_tree *tree; struct parameters params; params = get_params(argc, argv); while (NULL != (tree = parse_tree())) { /* tree is free()d in process_tree(), as derooting is * compatible with ordinary free()ing (with destroy_tree()), * but rerooting is not. */ process_tree(tree, params); } destroy_llist(params.labels); return 0; }
/* Diff two trees. */ static int stdin_diff_trees(struct tree *tree1, const char *p) { struct object_id oid; struct tree *tree2; if (!isspace(*p++) || parse_oid_hex(p, &oid, &p) || *p) return error("Need exactly two trees, separated by a space"); tree2 = lookup_tree(&oid); if (!tree2 || parse_tree(tree2)) return -1; printf("%s %s\n", oid_to_hex(&tree1->object.oid), oid_to_hex(&tree2->object.oid)); diff_tree_oid(&tree1->object.oid, &tree2->object.oid, "", &log_tree_opt.diffopt); log_tree_diff_flush(&log_tree_opt); return 0; }
/* Diff two trees. */ static int stdin_diff_trees(struct tree *tree1, char *line, int len) { unsigned char sha1[20]; struct tree *tree2; if (len != 82 || !isspace(line[40]) || get_sha1_hex(line + 41, sha1)) return error("Need exactly two trees, separated by a space"); tree2 = lookup_tree(sha1); if (!tree2 || parse_tree(tree2)) return -1; printf("%s %s\n", sha1_to_hex(tree1->object.sha1), sha1_to_hex(tree2->object.sha1)); diff_tree_sha1(tree1->object.sha1, tree2->object.sha1, "", &log_tree_opt.diffopt); log_tree_diff_flush(&log_tree_opt); return 0; }
static int checkout_fast_forward(unsigned char *head, unsigned char *remote) { struct tree *trees[MAX_UNPACK_TREES]; struct unpack_trees_options opts; struct tree_desc t[MAX_UNPACK_TREES]; int i, fd, nr_trees = 0; struct dir_struct dir; struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file)); refresh_cache(REFRESH_QUIET); fd = hold_locked_index(lock_file, 1); memset(&trees, 0, sizeof(trees)); memset(&opts, 0, sizeof(opts)); memset(&t, 0, sizeof(t)); memset(&dir, 0, sizeof(dir)); dir.flags |= DIR_SHOW_IGNORED; dir.exclude_per_dir = ".gitignore"; opts.dir = &dir; opts.head_idx = 1; opts.src_index = &the_index; opts.dst_index = &the_index; opts.update = 1; opts.verbose_update = 1; opts.merge = 1; opts.fn = twoway_merge; opts.msgs = get_porcelain_error_msgs(); trees[nr_trees] = parse_tree_indirect(head); if (!trees[nr_trees++]) return -1; trees[nr_trees] = parse_tree_indirect(remote); if (!trees[nr_trees++]) return -1; for (i = 0; i < nr_trees; i++) { parse_tree(trees[i]); init_tree_desc(t+i, trees[i]->buffer, trees[i]->size); } if (unpack_trees(nr_trees, t, &opts)) return -1; if (write_cache(fd, active_cache, active_nr) || commit_locked_index(lock_file)) die("unable to write new index file"); return 0; }
static int checkout_fast_forward(unsigned char *head, unsigned char *remote) { struct tree *trees[MAX_UNPACK_TREES]; struct unpack_trees_options opts; struct tree_desc t[MAX_UNPACK_TREES]; int i, fd, nr_trees = 0; struct dir_struct dir; struct lock_file *lock_file = xcalloc(1, sizeof(struct lock_file)); if (read_cache_unmerged()) die("you need to resolve your current index first"); fd = hold_locked_index(lock_file, 1); memset(&trees, 0, sizeof(trees)); memset(&opts, 0, sizeof(opts)); memset(&t, 0, sizeof(t)); dir.show_ignored = 1; dir.exclude_per_dir = ".gitignore"; opts.dir = &dir; opts.head_idx = 1; opts.src_index = &the_index; opts.dst_index = &the_index; opts.update = 1; opts.verbose_update = 1; opts.merge = 1; opts.fn = twoway_merge; trees[nr_trees] = parse_tree_indirect(head); if (!trees[nr_trees++]) return -1; trees[nr_trees] = parse_tree_indirect(remote); if (!trees[nr_trees++]) return -1; for (i = 0; i < nr_trees; i++) { parse_tree(trees[i]); init_tree_desc(t+i, trees[i]->buffer, trees[i]->size); } if (unpack_trees(nr_trees, t, &opts)) return -1; if (write_cache(fd, active_cache, active_nr) || commit_locked_index(lock_file)) die("unable to write new index file"); return 0; }
int read_tree_recursive(struct tree *tree, const char *base, int baselen, int stage, const char **match, read_tree_fn_t fn) { struct tree_desc desc; struct name_entry entry; if (parse_tree(tree)) return -1; init_tree_desc(&desc, tree->buffer, tree->size); while (tree_entry(&desc, &entry)) { if (!match_tree_entry(base, baselen, entry.path, entry.mode, match)) continue; switch (fn(entry.sha1, base, baselen, entry.path, entry.mode, stage)) { case 0: continue; case READ_TREE_RECURSIVE: break;; default: return -1; } if (S_ISDIR(entry.mode)) { int retval; char *newbase; unsigned int pathlen = tree_entry_len(entry.path, entry.sha1); newbase = xmalloc(baselen + 1 + pathlen); memcpy(newbase, base, baselen); memcpy(newbase + baselen, entry.path, pathlen); newbase[baselen + pathlen] = '/'; retval = read_tree_recursive(lookup_tree(entry.sha1), newbase, baselen + pathlen + 1, stage, match, fn); free(newbase); if (retval) return -1; continue; } } return 0; }
void parse(std::wostream &stream, wstring templ_text, data_map &data) { token_vector tokens ; tokenize(templ_text, tokens) ; token_vector tree ; parse_tree(tokens, tree) ; for (size_t i = 0 ; i < tree.size() ; ++i) { // Recursively calls gettext on each node in the tree. // gettext returns the appropriate text for that node. // for text, itself; // for variable, substitution; // for control statement, recursively gets kids tree[i]->gettext(stream, data) ; } }
static int fsck_walk_tree(struct tree *tree, void *data, struct fsck_options *options) { struct tree_desc desc; struct name_entry entry; int res = 0; const char *name; if (parse_tree(tree)) return -1; name = get_object_name(options, &tree->object); if (init_tree_desc_gently(&desc, tree->buffer, tree->size)) return -1; while (tree_entry_gently(&desc, &entry)) { struct object *obj; int result; if (S_ISGITLINK(entry.mode)) continue; if (S_ISDIR(entry.mode)) { obj = (struct object *)lookup_tree(entry.oid); if (name && obj) put_object_name(options, obj, "%s%s/", name, entry.path); result = options->walk(obj, OBJ_TREE, data, options); } else if (S_ISREG(entry.mode) || S_ISLNK(entry.mode)) { obj = (struct object *)lookup_blob(entry.oid); if (name && obj) put_object_name(options, obj, "%s%s", name, entry.path); result = options->walk(obj, OBJ_BLOB, data, options); } else { result = error("in tree %s: entry %s has bad mode %.6o", describe_object(options, &tree->object), entry.path, entry.mode); } if (result < 0) return result; if (!res) res = result; } return res; }
int main(int argc, char *argv[]) { struct rooted_tree *tree; struct parameters params; params = get_params(argc, argv); while (NULL != (tree = parse_tree())) { /* tree is free()d in process_tree(), as derooting is * compatible with ordinary free()ing (with * destroy_tree()), but rerooting is not. */ // TODO: why not? Can this be obsolete now that rnodes are // free()d at the end? process_tree(tree, params); } destroy_llist(params.labels); return 0; }
static void process_tree(struct rev_info *revs, struct tree *tree, struct object_array *p, struct name_path *path, const char *name) { struct object *obj = &tree->object; struct tree_desc desc; struct name_entry entry; struct name_path me; if (!revs->tree_objects) return; if (!obj) die("bad tree object"); if (obj->flags & (UNINTERESTING | SEEN)) return; if (parse_tree(tree) < 0) die("bad tree object %s", sha1_to_hex(obj->sha1)); obj->flags |= SEEN; name = xstrdup(name); add_object(obj, p, path, name); me.up = path; me.elem = name; me.elem_len = strlen(name); init_tree_desc(&desc, tree->buffer, tree->size); while (tree_entry(&desc, &entry)) { if (S_ISDIR(entry.mode)) process_tree(revs, lookup_tree(entry.sha1), p, &me, entry.path); else if (S_ISGITLINK(entry.mode)) process_gitlink(revs, entry.sha1, p, &me, entry.path); else process_blob(revs, lookup_blob(entry.sha1), p, &me, entry.path); } free(tree->buffer); tree->buffer = NULL; }
void insert_node(t_hash_tree **tree, t_list *lst) { t_hash_tree *tmp_node; t_hash_tree *tmp_tree; t_hash_tree *elem; elem = ft_memalloc(sizeof(t_hash_tree)); tmp_tree = *tree; tmp_node = NULL; elem->node = lst; elem->indice = lst->indice; elem->left = NULL; elem->right = NULL; elem->equal = NULL; if (tmp_tree) parse_tree(tmp_tree, tmp_node, elem); else *tree = elem; }
static int reset_tree(struct object_id *i_tree, int update, int reset) { int nr_trees = 1; struct unpack_trees_options opts; struct tree_desc t[MAX_UNPACK_TREES]; struct tree *tree; struct lock_file lock_file = LOCK_INIT; read_cache_preload(NULL); if (refresh_cache(REFRESH_QUIET)) return -1; hold_locked_index(&lock_file, LOCK_DIE_ON_ERROR); memset(&opts, 0, sizeof(opts)); tree = parse_tree_indirect(i_tree); if (parse_tree(tree)) return -1; init_tree_desc(t, tree->buffer, tree->size); opts.head_idx = 1; opts.src_index = &the_index; opts.dst_index = &the_index; opts.merge = 1; opts.reset = reset; opts.update = update; opts.fn = oneway_merge; if (unpack_trees(nr_trees, t, &opts)) return -1; if (write_locked_index(&the_index, &lock_file, COMMIT_LOCK)) return error(_("unable to write new index file")); return 0; }
void mark_tree_uninteresting(struct tree *tree) { struct tree_desc desc; struct name_entry entry; struct object *obj = &tree->object; if (!tree) return; if (obj->flags & UNINTERESTING) return; obj->flags |= UNINTERESTING; if (!has_sha1_file(obj->sha1)) return; if (parse_tree(tree) < 0) die("bad tree %s", sha1_to_hex(obj->sha1)); init_tree_desc(&desc, tree->buffer, tree->size); while (tree_entry(&desc, &entry)) { switch (object_type(entry.mode)) { case OBJ_TREE: mark_tree_uninteresting(lookup_tree(entry.sha1)); break; case OBJ_BLOB: mark_blob_uninteresting(lookup_blob(entry.sha1)); break; default: /* Subproject commit - not in this repository */ break; } } /* * We don't care about the tree any more * after it has been marked uninteresting. */ free(tree->buffer); tree->buffer = NULL; }
void solid_import(solid_vm *vm) { char *input = get_str_value(pop_stack(vm)); char *dot = strrchr(input, '.'); char *extension; if (!dot || dot == input) { extension = ""; } extension = dot + 1; if (strcmp(extension, "sol") == 0) { solid_object *func = parse_tree(parse_file(input)); solid_call_func(vm, func); } else if (strcmp(extension, "so") == 0) { void *handle = dlopen(input, RTLD_LAZY); void (*init)(solid_vm *); if (handle == NULL) { log_err("Loading external library %s failed with error %s", input, dlerror()); } dlerror(); *(void **) (&init) = dlsym(handle, "solid_init"); init(vm); //dlclose(handle); } }