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; }
struct tree *write_tree_from_memory(struct merge_options *o) { struct tree *result = NULL; if (unmerged_cache()) { int i; fprintf(stderr, "BUG: There are unmerged index entries:\n"); for (i = 0; i < active_nr; i++) { struct cache_entry *ce = active_cache[i]; if (ce_stage(ce)) fprintf(stderr, "BUG: %d %.*s", ce_stage(ce), (int)ce_namelen(ce), ce->name); } die("Bug in merge-recursive.c"); } if (!active_cache_tree) active_cache_tree = cache_tree(); if (!cache_tree_fully_valid(active_cache_tree) && cache_tree_update(active_cache_tree, active_cache, active_nr, 0, 0) < 0) die("error building trees"); result = lookup_tree(active_cache_tree->sha1); return result; }
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; }
struct tree *write_tree_from_memory(struct merge_options *o) { struct tree *result = NULL; if (unmerged_cache()) { int i; output(o, 0, "There are unmerged index entries:"); for (i = 0; i < active_nr; i++) { struct cache_entry *ce = active_cache[i]; if (ce_stage(ce)) output(o, 0, "%d %.*s", ce_stage(ce), ce_namelen(ce), ce->name); } return NULL; } if (!active_cache_tree) active_cache_tree = cache_tree(); if (!cache_tree_fully_valid(active_cache_tree) && cache_tree_update(active_cache_tree, active_cache, active_nr, 0, 0) < 0) die("error building trees"); result = lookup_tree(active_cache_tree->sha1); return result; }
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 parse_tag_buffer(struct tag *item, const void *data, unsigned long size) { unsigned char sha1[20]; char type[20]; const char *bufptr = data; const char *tail = bufptr + size; const char *nl; if (item->object.parsed) return 0; item->object.parsed = 1; if (size < 64) return -1; if (memcmp("object ", bufptr, 7) || get_sha1_hex(bufptr + 7, sha1) || bufptr[47] != '\n') return -1; bufptr += 48; /* "object " + sha1 + "\n" */ if (!starts_with(bufptr, "type ")) return -1; bufptr += 5; nl = memchr(bufptr, '\n', tail - bufptr); if (!nl || sizeof(type) <= (nl - bufptr)) return -1; memcpy(type, bufptr, nl - bufptr); type[nl - bufptr] = '\0'; bufptr = nl + 1; if (!strcmp(type, blob_type)) { item->tagged = &lookup_blob(sha1)->object; } else if (!strcmp(type, tree_type)) { item->tagged = &lookup_tree(sha1)->object; } else if (!strcmp(type, commit_type)) { item->tagged = &lookup_commit(sha1)->object; } else if (!strcmp(type, tag_type)) { item->tagged = &lookup_tag(sha1)->object; } else { error("Unknown type %s", type); item->tagged = NULL; } if (bufptr + 4 < tail && starts_with(bufptr, "tag ")) ; /* good */ else return -1; bufptr += 4; nl = memchr(bufptr, '\n', tail - bufptr); if (!nl) return -1; item->tag = xmemdupz(bufptr, nl - bufptr); bufptr = nl + 1; if (bufptr + 7 < tail && starts_with(bufptr, "tagger ")) item->date = parse_tag_date(bufptr, tail); else item->date = 0; return 0; }
int parse_tag_buffer(struct tag *item, const void *data, unsigned long size) { struct object_id oid; char type[20]; const char *bufptr = data; const char *tail = bufptr + size; const char *nl; if (item->object.parsed) return 0; item->object.parsed = 1; if (size < GIT_SHA1_HEXSZ + 24) return -1; if (memcmp("object ", bufptr, 7) || parse_oid_hex(bufptr + 7, &oid, &bufptr) || *bufptr++ != '\n') return -1; if (!starts_with(bufptr, "type ")) return -1; bufptr += 5; nl = memchr(bufptr, '\n', tail - bufptr); if (!nl || sizeof(type) <= (nl - bufptr)) return -1; memcpy(type, bufptr, nl - bufptr); type[nl - bufptr] = '\0'; bufptr = nl + 1; if (!strcmp(type, blob_type)) { item->tagged = (struct object *)lookup_blob(&oid); } else if (!strcmp(type, tree_type)) { item->tagged = (struct object *)lookup_tree(&oid); } else if (!strcmp(type, commit_type)) { item->tagged = (struct object *)lookup_commit(&oid); } else if (!strcmp(type, tag_type)) { item->tagged = (struct object *)lookup_tag(&oid); } else { error("Unknown type %s", type); item->tagged = NULL; } if (bufptr + 4 < tail && starts_with(bufptr, "tag ")) ; /* good */ else return -1; bufptr += 4; nl = memchr(bufptr, '\n', tail - bufptr); if (!nl) return -1; item->tag = xmemdupz(bufptr, nl - bufptr); bufptr = nl + 1; if (bufptr + 7 < tail && starts_with(bufptr, "tagger ")) item->date = parse_tag_date(bufptr, tail); else item->date = 0; return 0; }
static struct tree *shift_tree_object(struct tree *one, struct tree *two) { unsigned char shifted[20]; /* * NEEDSWORK: this limits the recursion depth to hardcoded * value '2' to avoid excessive overhead. */ shift_tree(one->object.sha1, two->object.sha1, shifted, 2); if (!hashcmp(two->object.sha1, shifted)) return two; return lookup_tree(shifted); }
struct object *parse_object_buffer(const struct object_id *oid, enum object_type type, unsigned long size, void *buffer, int *eaten_p) { struct object *obj; *eaten_p = 0; obj = NULL; if (type == OBJ_BLOB) { struct blob *blob = lookup_blob(oid); if (blob) { if (parse_blob_buffer(blob, buffer, size)) return NULL; obj = &blob->object; } } else if (type == OBJ_TREE) { struct tree *tree = lookup_tree(oid); if (tree) { obj = &tree->object; if (!tree->buffer) tree->object.parsed = 0; if (!tree->object.parsed) { if (parse_tree_buffer(tree, buffer, size)) return NULL; *eaten_p = 1; } } } else if (type == OBJ_COMMIT) { struct commit *commit = lookup_commit(oid); if (commit) { if (parse_commit_buffer(commit, buffer, size)) return NULL; if (!get_cached_commit_buffer(commit, NULL)) { set_commit_buffer(commit, buffer, size); *eaten_p = 1; } obj = &commit->object; } } else if (type == OBJ_TAG) { struct tag *tag = lookup_tag(oid); if (tag) { if (parse_tag_buffer(tag, buffer, size)) return NULL; obj = &tag->object; } } else { warning("object %s has unknown type id %d", oid_to_hex(oid), type); obj = NULL; } return obj; }
static struct tree *shift_tree_object(struct tree *one, struct tree *two, const char *subtree_shift) { unsigned char shifted[20]; if (!*subtree_shift) { shift_tree(one->object.sha1, two->object.sha1, shifted, 0); } else { shift_tree_by(one->object.sha1, two->object.sha1, shifted, subtree_shift); } if (!hashcmp(two->object.sha1, shifted)) return two; return lookup_tree(shifted); }
/* 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; }
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; }
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; }
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; }
static int tree_is_complete(const struct object_id *oid) { struct tree_desc desc; struct name_entry entry; int complete; struct tree *tree; tree = lookup_tree(the_repository, oid); if (!tree) return 0; if (tree->object.flags & SEEN) return 1; if (tree->object.flags & INCOMPLETE) return 0; if (!tree->buffer) { enum object_type type; unsigned long size; void *data = read_object_file(oid, &type, &size); if (!data) { tree->object.flags |= INCOMPLETE; return 0; } tree->buffer = data; tree->size = size; } init_tree_desc(&desc, tree->buffer, tree->size); complete = 1; while (tree_entry(&desc, &entry)) { if (!has_object_file(&entry.oid) || (S_ISDIR(entry.mode) && !tree_is_complete(&entry.oid))) { tree->object.flags |= INCOMPLETE; complete = 0; } } free_tree_buffer(tree); if (complete) tree->object.flags |= SEEN; return complete; }
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; }
static struct tree *empty_tree(void) { return lookup_tree((const unsigned char *)EMPTY_TREE_SHA1_BIN); }
static void process_tree(struct rev_info *revs, struct tree *tree, show_object_fn show, struct strbuf *base, const char *name, void *cb_data) { struct object *obj = &tree->object; struct tree_desc desc; struct name_entry entry; enum interesting match = revs->diffopt.pathspec.nr == 0 ? all_entries_interesting: entry_not_interesting; int baselen = base->len; if (!revs->tree_objects) return; if (!obj) die("bad tree object"); if (obj->flags & (UNINTERESTING | SEEN)) return; if (parse_tree_gently(tree, revs->ignore_missing_links) < 0) { if (revs->ignore_missing_links) return; die("bad tree object %s", oid_to_hex(&obj->oid)); } obj->flags |= SEEN; strbuf_addstr(base, name); show(obj, base->buf, cb_data); if (base->len) strbuf_addch(base, '/'); init_tree_desc(&desc, tree->buffer, tree->size); while (tree_entry(&desc, &entry)) { if (match != all_entries_interesting) { match = tree_entry_interesting(&entry, base, 0, &revs->diffopt.pathspec); if (match == all_entries_not_interesting) break; if (match == entry_not_interesting) continue; } if (S_ISDIR(entry.mode)) process_tree(revs, lookup_tree(entry.sha1), show, base, entry.path, cb_data); else if (S_ISGITLINK(entry.mode)) process_gitlink(revs, entry.sha1, show, base, entry.path, cb_data); else process_blob(revs, lookup_blob(entry.sha1), show, base, entry.path, cb_data); } strbuf_setlen(base, baselen); free_tree_buffer(tree); }
int cmd_diff(int argc, const char **argv, const char *prefix) { int i; struct rev_info rev; struct object_array_entry ent[100]; int ents = 0, blobs = 0, paths = 0; const char *path = NULL; struct blobinfo blob[2]; int nongit; int result = 0; /* * We could get N tree-ish in the rev.pending_objects list. * Also there could be M blobs there, and P pathspecs. * * N=0, M=0: * cache vs files (diff-files) * N=0, M=2: * compare two random blobs. P must be zero. * N=0, M=1, P=1: * compare a blob with a working tree file. * * N=1, M=0: * tree vs cache (diff-index --cached) * * N=2, M=0: * tree vs tree (diff-tree) * * N=0, M=0, P=2: * compare two filesystem entities (aka --no-index). * * Other cases are errors. */ prefix = setup_git_directory_gently(&nongit); gitmodules_config(); git_config(git_diff_ui_config, NULL); if (diff_use_color_default == -1) diff_use_color_default = git_use_color_default; init_revisions(&rev, prefix); /* If this is a no-index diff, just run it and exit there. */ diff_no_index(&rev, argc, argv, nongit, prefix); /* Otherwise, we are doing the usual "git" diff */ rev.diffopt.skip_stat_unmatch = !!diff_auto_refresh_index; /* Default to let external and textconv be used */ DIFF_OPT_SET(&rev.diffopt, ALLOW_EXTERNAL); DIFF_OPT_SET(&rev.diffopt, ALLOW_TEXTCONV); if (nongit) die("Not a git repository"); argc = setup_revisions(argc, argv, &rev, NULL); if (!rev.diffopt.output_format) { rev.diffopt.output_format = DIFF_FORMAT_PATCH; if (diff_setup_done(&rev.diffopt) < 0) die("diff_setup_done failed"); } DIFF_OPT_SET(&rev.diffopt, RECURSIVE); /* * If the user asked for our exit code then don't start a * pager or we would end up reporting its exit code instead. */ if (!DIFF_OPT_TST(&rev.diffopt, EXIT_WITH_STATUS) && check_pager_config("diff") != 0) setup_pager(); /* * Do we have --cached and not have a pending object, then * default to HEAD by hand. Eek. */ if (!rev.pending.nr) { int i; for (i = 1; i < argc; i++) { const char *arg = argv[i]; if (!strcmp(arg, "--")) break; else if (!strcmp(arg, "--cached") || !strcmp(arg, "--staged")) { add_head_to_pending(&rev); if (!rev.pending.nr) { struct tree *tree; tree = lookup_tree((const unsigned char*)EMPTY_TREE_SHA1_BIN); add_pending_object(&rev, &tree->object, "HEAD"); } break; } } } for (i = 0; i < rev.pending.nr; i++) { struct object_array_entry *list = rev.pending.objects+i; struct object *obj = list->item; const char *name = list->name; int flags = (obj->flags & UNINTERESTING); if (!obj->parsed) obj = parse_object(obj->sha1); obj = deref_tag(obj, NULL, 0); if (!obj) die("invalid object '%s' given.", name); if (obj->type == OBJ_COMMIT) obj = &((struct commit *)obj)->tree->object; if (obj->type == OBJ_TREE) { if (ARRAY_SIZE(ent) <= ents) die("more than %d trees given: '%s'", (int) ARRAY_SIZE(ent), name); obj->flags |= flags; ent[ents].item = obj; ent[ents].name = name; ents++; continue; } if (obj->type == OBJ_BLOB) { if (2 <= blobs) die("more than two blobs given: '%s'", name); hashcpy(blob[blobs].sha1, obj->sha1); blob[blobs].name = name; blob[blobs].mode = list->mode; blobs++; continue; } die("unhandled object '%s' given.", name); } if (rev.prune_data.nr) { if (!path) path = rev.prune_data.items[0].match; paths += rev.prune_data.nr; } /* * Now, do the arguments look reasonable? */ if (!ents) { switch (blobs) { case 0: result = builtin_diff_files(&rev, argc, argv); break; case 1: if (paths != 1) usage(builtin_diff_usage); result = builtin_diff_b_f(&rev, argc, argv, blob, path); break; case 2: if (paths) usage(builtin_diff_usage); result = builtin_diff_blobs(&rev, argc, argv, blob); break; default: usage(builtin_diff_usage); } } else if (blobs) usage(builtin_diff_usage); else if (ents == 1) result = builtin_diff_index(&rev, argc, argv); else if (ents == 2) result = builtin_diff_tree(&rev, argc, argv, ent); else if (ent[0].item->flags & UNINTERESTING) { /* * diff A...B where there is at least one merge base * between A and B. We have ent[0] == merge-base, * ent[ents-2] == A, and ent[ents-1] == B. Show diff * between the base and B. Note that we pick one * merge base at random if there are more than one. */ ent[1] = ent[ents-1]; result = builtin_diff_tree(&rev, argc, argv, ent); } else result = builtin_diff_combined(&rev, argc, argv, ent, ents); result = diff_result_code(&rev.diffopt, result); if (1 < rev.diffopt.skip_stat_unmatch) refresh_index_quietly(); return result; }
int cmd_diff(int argc, const char **argv, const char *prefix) { int i; struct rev_info rev; struct object_array ent = OBJECT_ARRAY_INIT; int blobs = 0, paths = 0; struct blobinfo blob[2]; int nongit; int result = 0; /* * We could get N tree-ish in the rev.pending_objects list. * Also there could be M blobs there, and P pathspecs. * * N=0, M=0: * cache vs files (diff-files) * N=0, M=2: * compare two random blobs. P must be zero. * N=0, M=1, P=1: * compare a blob with a working tree file. * * N=1, M=0: * tree vs cache (diff-index --cached) * * N=2, M=0: * tree vs tree (diff-tree) * * N=0, M=0, P=2: * compare two filesystem entities (aka --no-index). * * Other cases are errors. */ prefix = setup_git_directory_gently(&nongit); gitmodules_config(); git_config(git_diff_ui_config, NULL); init_revisions(&rev, prefix); /* If this is a no-index diff, just run it and exit there. */ diff_no_index(&rev, argc, argv, nongit, prefix); /* Otherwise, we are doing the usual "git" diff */ rev.diffopt.skip_stat_unmatch = !!diff_auto_refresh_index; /* Scale to real terminal size and respect statGraphWidth config */ rev.diffopt.stat_width = -1; rev.diffopt.stat_graph_width = -1; /* Default to let external and textconv be used */ DIFF_OPT_SET(&rev.diffopt, ALLOW_EXTERNAL); DIFF_OPT_SET(&rev.diffopt, ALLOW_TEXTCONV); if (nongit) die(_("Not a git repository")); argc = setup_revisions(argc, argv, &rev, NULL); if (!rev.diffopt.output_format) { rev.diffopt.output_format = DIFF_FORMAT_PATCH; diff_setup_done(&rev.diffopt); } DIFF_OPT_SET(&rev.diffopt, RECURSIVE); setup_diff_pager(&rev.diffopt); /* * Do we have --cached and not have a pending object, then * default to HEAD by hand. Eek. */ if (!rev.pending.nr) { int i; for (i = 1; i < argc; i++) { const char *arg = argv[i]; if (!strcmp(arg, "--")) break; else if (!strcmp(arg, "--cached") || !strcmp(arg, "--staged")) { add_head_to_pending(&rev); if (!rev.pending.nr) { struct tree *tree; tree = lookup_tree(EMPTY_TREE_SHA1_BIN); add_pending_object(&rev, &tree->object, "HEAD"); } break; } } } for (i = 0; i < rev.pending.nr; i++) { struct object_array_entry *entry = &rev.pending.objects[i]; struct object *obj = entry->item; const char *name = entry->name; int flags = (obj->flags & UNINTERESTING); if (!obj->parsed) obj = parse_object(obj->sha1); obj = deref_tag(obj, NULL, 0); if (!obj) die(_("invalid object '%s' given."), name); if (obj->type == OBJ_COMMIT) obj = &((struct commit *)obj)->tree->object; if (obj->type == OBJ_TREE) { obj->flags |= flags; add_object_array(obj, name, &ent); } else if (obj->type == OBJ_BLOB) { if (2 <= blobs) die(_("more than two blobs given: '%s'"), name); hashcpy(blob[blobs].sha1, obj->sha1); blob[blobs].name = name; blob[blobs].mode = entry->mode; blobs++; } else { die(_("unhandled object '%s' given."), name); } } if (rev.prune_data.nr) paths += rev.prune_data.nr; /* * Now, do the arguments look reasonable? */ if (!ent.nr) { switch (blobs) { case 0: result = builtin_diff_files(&rev, argc, argv); break; case 1: if (paths != 1) usage(builtin_diff_usage); result = builtin_diff_b_f(&rev, argc, argv, blob); break; case 2: if (paths) usage(builtin_diff_usage); result = builtin_diff_blobs(&rev, argc, argv, blob); break; default: usage(builtin_diff_usage); } } else if (blobs) usage(builtin_diff_usage); else if (ent.nr == 1) result = builtin_diff_index(&rev, argc, argv); else if (ent.nr == 2) result = builtin_diff_tree(&rev, argc, argv, &ent.objects[0], &ent.objects[1]); else if (ent.objects[0].item->flags & UNINTERESTING) { /* * diff A...B where there is at least one merge base * between A and B. We have ent.objects[0] == * merge-base, ent.objects[ents-2] == A, and * ent.objects[ents-1] == B. Show diff between the * base and B. Note that we pick one merge base at * random if there are more than one. */ result = builtin_diff_tree(&rev, argc, argv, &ent.objects[0], &ent.objects[ent.nr-1]); } else result = builtin_diff_combined(&rev, argc, argv, ent.objects, ent.nr); result = diff_result_code(&rev.diffopt, result); if (1 < rev.diffopt.skip_stat_unmatch) refresh_index_quietly(); return result; }
int parse_commit_buffer(struct commit *item, void *buffer, unsigned long size) { char *bufptr = buffer; unsigned char parent[20]; struct commit_list **pptr; struct commit_graft *graft; unsigned n_refs = 0; if (item->object.parsed) return 0; item->object.parsed = 1; if (memcmp(bufptr, "tree ", 5)) return error("bogus commit object %s", sha1_to_hex(item->object.sha1)); if (get_sha1_hex(bufptr + 5, parent) < 0) return error("bad tree pointer in commit %s\n", sha1_to_hex(item->object.sha1)); item->tree = lookup_tree(parent); if (item->tree) n_refs++; bufptr += 46; /* "tree " + "hex sha1" + "\n" */ pptr = &item->parents; graft = lookup_commit_graft(item->object.sha1); while (!memcmp(bufptr, "parent ", 7)) { struct commit *new_parent; if (get_sha1_hex(bufptr + 7, parent) || bufptr[47] != '\n') return error("bad parents in commit %s", sha1_to_hex(item->object.sha1)); bufptr += 48; if (graft) continue; new_parent = lookup_commit(parent); if (new_parent) { pptr = &commit_list_insert(new_parent, pptr)->next; n_refs++; } } if (graft) { int i; struct commit *new_parent; for (i = 0; i < graft->nr_parent; i++) { new_parent = lookup_commit(graft->parent[i]); if (!new_parent) continue; pptr = &commit_list_insert(new_parent, pptr)->next; n_refs++; } } item->date = parse_commit_date(bufptr); if (track_object_refs) { unsigned i = 0; struct commit_list *p; struct object_refs *refs = alloc_object_refs(n_refs); if (item->tree) refs->ref[i++] = &item->tree->object; for (p = item->parents; p; p = p->next) refs->ref[i++] = &p->item->object; set_object_refs(&item->object, refs); } return 0; }
static struct tree *empty_tree(void) { return lookup_tree(EMPTY_TREE_SHA1_BIN); }
static int read_tree_1(struct tree *tree, struct strbuf *base, int stage, const struct pathspec *pathspec, read_tree_fn_t fn, void *context) { struct tree_desc desc; struct name_entry entry; unsigned char sha1[20]; int len, oldlen = base->len; enum interesting retval = entry_not_interesting; if (parse_tree(tree)) return -1; init_tree_desc(&desc, tree->buffer, tree->size); while (tree_entry(&desc, &entry)) { if (retval != all_entries_interesting) { retval = tree_entry_interesting(&entry, base, 0, pathspec); if (retval == all_entries_not_interesting) break; if (retval == entry_not_interesting) continue; } switch (fn(entry.sha1, base, entry.path, entry.mode, stage, context)) { case 0: continue; case READ_TREE_RECURSIVE: break; default: return -1; } if (S_ISDIR(entry.mode)) hashcpy(sha1, entry.sha1); else if (S_ISGITLINK(entry.mode)) { struct commit *commit; commit = lookup_commit(entry.sha1); if (!commit) die("Commit %s in submodule path %s%s not found", sha1_to_hex(entry.sha1), base->buf, entry.path); if (parse_commit(commit)) die("Invalid commit %s in submodule path %s%s", sha1_to_hex(entry.sha1), base->buf, entry.path); hashcpy(sha1, commit->tree->object.sha1); } else continue; len = tree_entry_len(&entry); strbuf_add(base, entry.path, len); strbuf_addch(base, '/'); retval = read_tree_1(lookup_tree(sha1), base, stage, pathspec, fn, context); strbuf_setlen(base, oldlen); if (retval) return -1; } return 0; }
static void process_tree(struct rev_info *revs, struct tree *tree, show_object_fn show, struct name_path *path, struct strbuf *base, const char *name) { struct object *obj = &tree->object; struct tree_desc desc; struct name_entry entry; struct name_path me; int all_interesting = (revs->diffopt.pathspec.nr == 0); int baselen = base->len; 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; show(obj, path, name); me.up = path; me.elem = name; me.elem_len = strlen(name); if (!all_interesting) { strbuf_addstr(base, name); if (base->len) strbuf_addch(base, '/'); } init_tree_desc(&desc, tree->buffer, tree->size); while (tree_entry(&desc, &entry)) { if (!all_interesting) { int showit = tree_entry_interesting(&entry, base, 0, &revs->diffopt.pathspec); if (showit < 0) break; else if (!showit) continue; else if (showit == 2) all_interesting = 1; } if (S_ISDIR(entry.mode)) process_tree(revs, lookup_tree(entry.sha1), show, &me, base, entry.path); else if (S_ISGITLINK(entry.mode)) process_gitlink(revs, entry.sha1, show, &me, entry.path); else process_blob(revs, lookup_blob(entry.sha1), show, &me, entry.path); } strbuf_setlen(base, baselen); free(tree->buffer); tree->buffer = NULL; }
void resolve_tree_islands(struct repository *r, int progress, struct packing_data *to_pack) { struct progress *progress_state = NULL; struct tree_islands_todo *todo; int nr = 0; int i; if (!island_marks) return; /* * We process only trees, as commits and tags have already been handled * (and passed their marks on to root trees, as well. We must make sure * to process them in descending tree-depth order so that marks * propagate down the tree properly, even if a sub-tree is found in * multiple parent trees. */ ALLOC_ARRAY(todo, to_pack->nr_objects); for (i = 0; i < to_pack->nr_objects; i++) { if (oe_type(&to_pack->objects[i]) == OBJ_TREE) { todo[nr].entry = &to_pack->objects[i]; todo[nr].depth = oe_tree_depth(to_pack, &to_pack->objects[i]); nr++; } } QSORT(todo, nr, tree_depth_compare); if (progress) progress_state = start_progress(_("Propagating island marks"), nr); for (i = 0; i < nr; i++) { struct object_entry *ent = todo[i].entry; struct island_bitmap *root_marks; struct tree *tree; struct tree_desc desc; struct name_entry entry; khiter_t pos; pos = kh_get_sha1(island_marks, ent->idx.oid.hash); if (pos >= kh_end(island_marks)) continue; root_marks = kh_value(island_marks, pos); tree = lookup_tree(r, &ent->idx.oid); if (!tree || parse_tree(tree) < 0) die(_("bad tree object %s"), oid_to_hex(&ent->idx.oid)); init_tree_desc(&desc, tree->buffer, tree->size); while (tree_entry(&desc, &entry)) { struct object *obj; if (S_ISGITLINK(entry.mode)) continue; obj = lookup_object(r, entry.oid->hash); if (!obj) continue; set_island_marks(obj, root_marks); } free_tree_buffer(tree); display_progress(progress_state, i+1); } stop_progress(&progress_state); free(todo); }
main () { tree_sTable *tp; sNode *np; int key; int i; char s[256]; char *cp; char c; tp = tree_CreateTable(sizeof(int), offsetof(sNode, key), sizeof(sNode), 100, tree_eComp_int32, NULL); for (i = 0; i < 1000; i += 10) { tree_Insert(tp, &i); } for ( ;;) { printf("Command: "); cp = gets(s); c = s[0]; if (cp == NULL || c == '\0') { printf("\nGoodbye\n"); return; } switch (c) { case 'i': case 'I': printf("Insert, Key: "); gets(s); key = atoi(s); if (tree_Find(tp, &key) == NULL) { tree_Insert(tp, &key); } else printf("\nKey allready exists!\n"); break; case 'd': case 'D': printf("Delete, Key: "); gets(s); key = atoi(s); if ((np = tree_Find(tp, &key)) != NULL) { tree_Remove(tp, &key); } else printf("\nKey does not exist!\n"); break; case 'f': case 'F': printf("Find, Key: "); gets(s); key = atoi(s); if ((np = tree_Find(tp, &key)) == NULL) { printf("\nKey does not exist!\n"); } else printf("\nKey exists! %d\n", np->key); break; case 's': case 'S': printf("Find successor, Key: "); gets(s); key = atoi(s); if ((np = tree_FindSuccessor(tp, &key)) == NULL) { printf("\nKey does not exist!\n"); } else printf("\nKey exists! %d\n", np->key); break; case 'p': case 'P': printf("Find predecessor, Key: "); gets(s); key = atoi(s); if ((np = tree_FindPredecessor(tp, &key)) == NULL) { printf("\nKey does not exist!\n"); } else printf("\nKey exists! %d\n", np->key); break; #if 0 case 't': case 'T': printf("Start: "); gets(s); start = atoi(s); printf("Stop: "); gets(s); stop = atoi(s); printf("Order: "); gets(s); c = s[0]; switch (c) { case 's': case 'S': printf("\navl-tree\n"); i = start; j = stop; sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); cpu = cputim; page = pageflts; for (; i <= j; i++) { if (TreeSearch(tp,i) == tp->Null) { np = TreeAlloc(tp, i); TreeInsert(tp, np); } } sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); printf("Cputim: %d, Pageflts: %d\n", cputim - cpu, pageflts - page); i = start; j = stop; printf("\nlib$tree\n"); sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); cpu = cputim; page = pageflts; for (; i <= j; i++) { sts = lib$lookup_tree(<p, i, Compare, &lnp); if (!(sts & 1)) { lib$insert_tree(<p, i, &0, Compare, Alloc, &lnp, 0); } } sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); printf("Cputim: %d, Pageflts: %d\n", cputim - cpu, pageflts - page); break; case 'd': case 'D': i = start; j = stop; sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); cpu = cputim; page = pageflts; for (; i <= j; i++) { if ((np = TreeSearch(tp,i)) != tp->Null) { TreeDelete(tp, np); } else { printf("Could not find %d\n", i); } } sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); printf("Cputim: %d, Pageflts: %d\n", cputim - cpu, pageflts - page); break; case 'f': case 'F': printf("\navl-tree\n"); i = start; j = stop; sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); cpu = cputim; page = pageflts; for (; i <= j; i++) { if ((np = TreeSearch(tp,i)) != tp->Null) { } else { printf("Could not find %d\n", i); } } sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); printf("Cputim: %d, Pageflts: %d\n", cputim - cpu, pageflts - page); i = start; j = stop; printf("\nlib$tree\n"); sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); cpu = cputim; page = pageflts; for (; i <= j; i++) { sts = lib$lookup_tree(<p, i, Compare, &lnp); } sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); printf("Cputim: %d, Pageflts: %d\n", cputim - cpu, pageflts - page); break; case 'b': case 'B': i = start; j = stop; sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); cpu = cputim; page = pageflts; for (; i <= j; j--) { if (TreeSearch(tp,j) == tp->Null) { np = TreeAlloc(tp, j); TreeInsert(tp, np); } } sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); printf("Cputim: %d, Pageflts: %d\n", cputim - cpu, pageflts - page); break; case 'r': case 'R': i = start; j = stop; sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); cpu = cputim; page = pageflts; for (; i <= j; i++) { k = 65535 & rand(); if (TreeSearch(tp,k) == tp->Null) { np = TreeAlloc(tp, k); TreeInsert(tp, np); } } sts = sys$getjpiw(0, &pid, 0,item_list, 0, 0, 0); printf("Cputim: %d, Pageflts: %d\n", cputim - cpu, pageflts - page); break; default: printf("Illegal order!\n"); break; } break; case 'p': case 'P': tp->ErrorCount = 0; tp->HZCount = 0; tp->HNCount = 0; tp->HPCount = 0; maxlevel = 0; count = 0; hight = 0; TreePrint(tp, tp->Root, NULL, NULL,0); TreeCheck (tp, tp->Root, &count, &maxlevel, &hight, 0); printf("Hight: %d\n", hight); #if 0 TreePrintInorder(tp, tp->Root, 0); #endif sp = TreeMinimum(tp, tp->Root); ep = TreeMaximum(tp, tp->Root); op = sp; for (np = TreeSuccessor(tp, op); op != ep; np = TreeSuccessor(tp, np)) { #if 0 printf("Key: %d\n", op->Key); #endif if (op->Key >= np->Key) tp->ErrorCount++; op = np; } printf("Hight.......: %d\n", hight); printf("Insert......: %d\n", tp->Insert); printf("Search......: %d\n", tp->Search); printf("Delete......: %d\n", tp->Delete); printf("NodeCount...: %d\n", tp->NodeCount); printf("FreeCount...: %d\n", tp->FreeCount); printf("MaxDepth....: %d\n", tp->MaxDepth); printf("HZCount.....: %d\n", tp->HZCount); printf("HNCount.....: %d\n", tp->HNCount); printf("HPCount.....: %d\n", tp->HPCount); printf("LLCount.....: %d\n", tp->LLCount); printf("LRCount.....: %d\n", tp->LRCount); printf("RLCount.....: %d\n", tp->RLCount); printf("RRCount.....: %d\n", tp->RRCount); printf("AllocCount..: %d\n", tp->AllocCount); printf("MallocCount.: %d\n", tp->MallocCount); printf("ErrorCount..: %d\n", tp->ErrorCount); count = maxlevel = 0; Print(ltp, &count, &maxlevel, 0); printf("\nlib$tree\n"); printf("Count.......: %d\n", count); printf("MaxDepth....: %d\n", maxlevel); break; case 'l': case 'L': TreePrintInorder(tp, tp->Root, 0); break; #endif case 'q': case 'Q': printf("\nGoodbye\n"); return; break; default: printf("Illegal command!\n"); break; } } }
int cmd_diff(int argc, const char **argv, const char *prefix) { int i; struct rev_info rev; struct object_array ent = OBJECT_ARRAY_INIT; int blobs = 0, paths = 0; struct blobinfo blob[2]; int nongit = 0, no_index = 0; int result = 0; /* * We could get N tree-ish in the rev.pending_objects list. * Also there could be M blobs there, and P pathspecs. * * N=0, M=0: * cache vs files (diff-files) * N=0, M=2: * compare two random blobs. P must be zero. * N=0, M=1, P=1: * compare a blob with a working tree file. * * N=1, M=0: * tree vs cache (diff-index --cached) * * N=2, M=0: * tree vs tree (diff-tree) * * N=0, M=0, P=2: * compare two filesystem entities (aka --no-index). * * Other cases are errors. */ /* Were we asked to do --no-index explicitly? */ for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "--")) { i++; break; } if (!strcmp(argv[i], "--no-index")) no_index = DIFF_NO_INDEX_EXPLICIT; if (argv[i][0] != '-') break; } if (!no_index) prefix = setup_git_directory_gently(&nongit); /* * Treat git diff with at least one path outside of the * repo the same as if the command would have been executed * outside of a git repository. In this case it behaves * the same way as "git diff --no-index <a> <b>", which acts * as a colourful "diff" replacement. */ if (nongit || ((argc == i + 2) && (!path_inside_repo(prefix, argv[i]) || !path_inside_repo(prefix, argv[i + 1])))) no_index = DIFF_NO_INDEX_IMPLICIT; if (!no_index) gitmodules_config(); init_diff_ui_defaults(); git_config(git_diff_ui_config, NULL); precompose_argv(argc, argv); init_revisions(&rev, prefix); if (no_index && argc != i + 2) { if (no_index == DIFF_NO_INDEX_IMPLICIT) { /* * There was no --no-index and there were not two * paths. It is possible that the user intended * to do an inside-repository operation. */ fprintf(stderr, "Not a git repository\n"); fprintf(stderr, "To compare two paths outside a working tree:\n"); } /* Give the usage message for non-repository usage and exit. */ usagef("git diff %s <path> <path>", no_index == DIFF_NO_INDEX_EXPLICIT ? "--no-index" : "[--no-index]"); } if (no_index) /* If this is a no-index diff, just run it and exit there. */ diff_no_index(&rev, argc, argv); /* Otherwise, we are doing the usual "git" diff */ rev.diffopt.skip_stat_unmatch = !!diff_auto_refresh_index; /* Scale to real terminal size and respect statGraphWidth config */ rev.diffopt.stat_width = -1; rev.diffopt.stat_graph_width = -1; /* Default to let external and textconv be used */ DIFF_OPT_SET(&rev.diffopt, ALLOW_EXTERNAL); DIFF_OPT_SET(&rev.diffopt, ALLOW_TEXTCONV); if (nongit) die(_("Not a git repository")); argc = setup_revisions(argc, argv, &rev, NULL); if (!rev.diffopt.output_format) { rev.diffopt.output_format = DIFF_FORMAT_PATCH; diff_setup_done(&rev.diffopt); } DIFF_OPT_SET(&rev.diffopt, RECURSIVE); setup_diff_pager(&rev.diffopt); /* * Do we have --cached and not have a pending object, then * default to HEAD by hand. Eek. */ if (!rev.pending.nr) { int i; for (i = 1; i < argc; i++) { const char *arg = argv[i]; if (!strcmp(arg, "--")) break; else if (!strcmp(arg, "--cached") || !strcmp(arg, "--staged")) { add_head_to_pending(&rev); if (!rev.pending.nr) { struct tree *tree; tree = lookup_tree(EMPTY_TREE_SHA1_BIN); add_pending_object(&rev, &tree->object, "HEAD"); } break; } } } for (i = 0; i < rev.pending.nr; i++) { struct object_array_entry *entry = &rev.pending.objects[i]; struct object *obj = entry->item; const char *name = entry->name; int flags = (obj->flags & UNINTERESTING); if (!obj->parsed) obj = parse_object(obj->oid.hash); obj = deref_tag(obj, NULL, 0); if (!obj) die(_("invalid object '%s' given."), name); if (obj->type == OBJ_COMMIT) obj = &((struct commit *)obj)->tree->object; if (obj->type == OBJ_TREE) { obj->flags |= flags; add_object_array(obj, name, &ent); } else if (obj->type == OBJ_BLOB) { if (2 <= blobs) die(_("more than two blobs given: '%s'"), name); hashcpy(blob[blobs].sha1, obj->oid.hash); blob[blobs].name = name; blob[blobs].mode = entry->mode; blobs++; } else { die(_("unhandled object '%s' given."), name); } } if (rev.prune_data.nr) paths += rev.prune_data.nr; /* * Now, do the arguments look reasonable? */ if (!ent.nr) { switch (blobs) { case 0: result = builtin_diff_files(&rev, argc, argv); break; case 1: if (paths != 1) usage(builtin_diff_usage); result = builtin_diff_b_f(&rev, argc, argv, blob); break; case 2: if (paths) usage(builtin_diff_usage); result = builtin_diff_blobs(&rev, argc, argv, blob); break; default: usage(builtin_diff_usage); } } else if (blobs) usage(builtin_diff_usage); else if (ent.nr == 1) result = builtin_diff_index(&rev, argc, argv); else if (ent.nr == 2) result = builtin_diff_tree(&rev, argc, argv, &ent.objects[0], &ent.objects[1]); else if (ent.objects[0].item->flags & UNINTERESTING) { /* * diff A...B where there is at least one merge base * between A and B. We have ent.objects[0] == * merge-base, ent.objects[ents-2] == A, and * ent.objects[ents-1] == B. Show diff between the * base and B. Note that we pick one merge base at * random if there are more than one. */ result = builtin_diff_tree(&rev, argc, argv, &ent.objects[0], &ent.objects[ent.nr-1]); } else result = builtin_diff_combined(&rev, argc, argv, ent.objects, ent.nr); result = diff_result_code(&rev.diffopt, result); if (1 < rev.diffopt.skip_stat_unmatch) refresh_index_quietly(); return result; }