static void check_aliased_update(struct command *cmd, struct string_list *list) { struct strbuf buf = STRBUF_INIT; const char *dst_name; struct string_list_item *item; struct command *dst_cmd; unsigned char sha1[20]; char cmd_oldh[41], cmd_newh[41], dst_oldh[41], dst_newh[41]; int flag; strbuf_addf(&buf, "%s%s", get_git_namespace(), cmd->ref_name); dst_name = resolve_ref_unsafe(buf.buf, sha1, 0, &flag); strbuf_release(&buf); if (!(flag & REF_ISSYMREF)) return; dst_name = strip_namespace(dst_name); if (!dst_name) { rp_error("refusing update to broken symref '%s'", cmd->ref_name); cmd->skip_update = 1; cmd->error_string = "broken symref"; return; } if ((item = string_list_lookup(list, dst_name)) == NULL) return; cmd->skip_update = 1; dst_cmd = (struct command *) item->util; if (!hashcmp(cmd->old_sha1, dst_cmd->old_sha1) && !hashcmp(cmd->new_sha1, dst_cmd->new_sha1)) return; dst_cmd->skip_update = 1; strcpy(cmd_oldh, find_unique_abbrev(cmd->old_sha1, DEFAULT_ABBREV)); strcpy(cmd_newh, find_unique_abbrev(cmd->new_sha1, DEFAULT_ABBREV)); strcpy(dst_oldh, find_unique_abbrev(dst_cmd->old_sha1, DEFAULT_ABBREV)); strcpy(dst_newh, find_unique_abbrev(dst_cmd->new_sha1, DEFAULT_ABBREV)); rp_error("refusing inconsistent update between symref '%s' (%s..%s) and" " its target '%s' (%s..%s)", cmd->ref_name, cmd_oldh, cmd_newh, dst_cmd->ref_name, dst_oldh, dst_newh); cmd->error_string = dst_cmd->error_string = "inconsistent aliased update"; }
static void describe_detached_head(const char *msg, struct commit *commit) { struct strbuf sb = STRBUF_INIT; if (!parse_commit(commit)) pp_commit_easy(CMIT_FMT_ONELINE, commit, &sb); if (print_sha1_ellipsis()) { fprintf(stderr, "%s %s... %s\n", msg, find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV), sb.buf); } else { fprintf(stderr, "%s %s %s\n", msg, find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV), sb.buf); } strbuf_release(&sb); }
static void print_commit(char sign, struct commit *commit, int verbose, int abbrev) { if (!verbose) { printf("%c %s\n", sign, find_unique_abbrev(commit->object.sha1, abbrev)); } else { struct strbuf buf = STRBUF_INIT; pp_commit_easy(CMIT_FMT_ONELINE, commit, &buf); printf("%c %s %s\n", sign, find_unique_abbrev(commit->object.sha1, abbrev), buf.buf); strbuf_release(&buf); } }
static int grab_1st_switch(unsigned char *osha1, unsigned char *nsha1, const char *email, unsigned long timestamp, int tz, const char *message, void *cb_data) { struct grab_1st_switch_cbdata *cb = cb_data; const char *target = NULL, *end; if (!starts_with(message, "checkout: moving from ")) return 0; message += strlen("checkout: moving from "); target = strstr(message, " to "); if (!target) return 0; target += strlen(" to "); strbuf_reset(&cb->buf); hashcpy(cb->nsha1, nsha1); for (end = target; *end && *end != '\n'; end++) ; if (!memcmp(target, "HEAD", end - target)) { /* HEAD is relative. Resolve it to the right reflog entry. */ strbuf_addstr(&cb->buf, find_unique_abbrev(nsha1, DEFAULT_ABBREV)); return 1; } strbuf_add(&cb->buf, target, end - target); return 1; }
/* * Turn * "pick d6a2f0303e897ec257dd0e0a39a5ccb709bc2047 some message" * into * "pick d6a2f03 some message" * * The function assumes that the line does not contain useless spaces * before or after the command. */ static void abbrev_sha1_in_line(struct strbuf *line) { struct strbuf **split; int i; if (starts_with(line->buf, "exec ") || starts_with(line->buf, "x ")) return; split = strbuf_split_max(line, ' ', 3); if (split[0] && split[1]) { unsigned char sha1[20]; const char *abbrev; /* * strbuf_split_max left a space. Trim it and re-add * it after abbreviation. */ strbuf_trim(split[1]); if (!get_sha1(split[1]->buf, sha1)) { abbrev = find_unique_abbrev(sha1, DEFAULT_ABBREV); strbuf_reset(split[1]); strbuf_addf(split[1], "%s ", abbrev); strbuf_reset(line); for (i = 0; split[i]; i++) strbuf_addf(line, "%s", split[i]->buf); } } for (i = 0; split[i]; i++) strbuf_release(split[i]); }
static void show_one_commit(struct commit *commit, int no_name) { char pretty[256], *cp; struct commit_name *name = commit->object.util; if (commit->object.parsed) pretty_print_commit(CMIT_FMT_ONELINE, commit->buffer, ~0, pretty, sizeof(pretty)); else strcpy(pretty, "(unavailable)"); if (!strncmp(pretty, "[PATCH] ", 8)) cp = pretty + 8; else cp = pretty; if (!no_name) { if (name && name->head_name) { printf("[%s", name->head_name); if (name->generation) { if (name->generation == 1) printf("^"); else printf("~%d", name->generation); } printf("] "); } else printf("[%s] ", find_unique_abbrev(commit->object.sha1, 7)); } puts(cp); }
/* * Extract branch information from rebase/bisect */ static void read_and_strip_branch(struct strbuf *sb, const char **branch, const char *path) { unsigned char sha1[20]; strbuf_reset(sb); if (strbuf_read_file(sb, git_path("%s", path), 0) <= 0) return; while (sb->len && sb->buf[sb->len - 1] == '\n') strbuf_setlen(sb, sb->len - 1); if (!sb->len) return; if (!prefixcmp(sb->buf, "refs/heads/")) *branch = sb->buf + strlen("refs/heads/"); else if (!prefixcmp(sb->buf, "refs/")) *branch = sb->buf; else if (!get_sha1_hex(sb->buf, sha1)) { const char *abbrev; abbrev = find_unique_abbrev(sha1, DEFAULT_ABBREV); strbuf_reset(sb); strbuf_addstr(sb, abbrev); *branch = sb->buf; } else if (!strcmp(sb->buf, "detached HEAD")) /* rebase */ ; else /* bisect */ *branch = sb->buf; }
static void add_merge_info(enum cmit_fmt fmt, struct strbuf *sb, const struct commit *commit, int abbrev) { struct commit_list *parent = commit->parents; if ((fmt == CMIT_FMT_ONELINE) || (fmt == CMIT_FMT_EMAIL) || !parent || !parent->next) return; strbuf_addstr(sb, "Merge:"); while (parent) { struct commit *p = parent->item; const char *hex = NULL; const char *dots; if (abbrev) hex = find_unique_abbrev(p->object.sha1, abbrev); if (!hex) hex = sha1_to_hex(p->object.sha1); dots = (abbrev && strlen(hex) != 40) ? "..." : ""; parent = parent->next; strbuf_addf(sb, " %s%s", hex, dots); } strbuf_addch(sb, '\n'); }
static void show_children(struct rev_info *opt, struct commit *commit, int abbrev) { struct commit_list *p = lookup_decoration(&opt->children, &commit->object); for ( ; p; p = p->next) { printf(" %s", find_unique_abbrev(p->item->object.sha1, abbrev)); } }
/* See grab_values */ static void grab_common_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz) { int i; for (i = 0; i < used_atom_cnt; i++) { const char *name = used_atom[i]; struct atom_value *v = &val[i]; if (!!deref != (*name == '*')) continue; if (deref) name++; if (!strcmp(name, "objecttype")) v->s = typename(obj->type); else if (!strcmp(name, "objectsize")) { char *s = xmalloc(40); sprintf(s, "%lu", sz); v->ul = sz; v->s = s; } else if (!strcmp(name, "objectname")) { char *s = xmalloc(41); strcpy(s, sha1_to_hex(obj->sha1)); v->s = s; } else if (!strcmp(name, "objectname:short")) { v->s = xstrdup(find_unique_abbrev(obj->sha1, DEFAULT_ABBREV)); } }
static void show_one_commit(struct commit *commit, int no_name) { struct strbuf pretty = STRBUF_INIT; const char *pretty_str = "(unavailable)"; struct commit_name *name = commit->util; if (commit->object.parsed) { struct pretty_print_context ctx = {0}; pretty_print_commit(CMIT_FMT_ONELINE, commit, &pretty, &ctx); pretty_str = pretty.buf; } if (!prefixcmp(pretty_str, "[PATCH] ")) pretty_str += 8; if (!no_name) { if (name && name->head_name) { printf("[%s", name->head_name); if (name->generation) { if (name->generation == 1) printf("^"); else printf("~%d", name->generation); } printf("] "); } else printf("[%s] ", find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV)); } puts(pretty_str); strbuf_release(&pretty); }
static int get_message(struct commit *commit, struct commit_message *out) { const char *abbrev, *subject; int abbrev_len, subject_len; char *q; if (!git_commit_encoding) git_commit_encoding = "UTF-8"; out->message = logmsg_reencode(commit, NULL, git_commit_encoding); abbrev = find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV); abbrev_len = strlen(abbrev); subject_len = find_commit_subject(out->message, &subject); out->parent_label = xmalloc(strlen("parent of ") + abbrev_len + strlen("... ") + subject_len + 1); q = out->parent_label; q = mempcpy(q, "parent of ", strlen("parent of ")); out->label = q; q = mempcpy(q, abbrev, abbrev_len); q = mempcpy(q, "... ", strlen("... ")); out->subject = q; q = mempcpy(q, subject, subject_len); *q = '\0'; return 0; }
static char *get_oneline(const char *message) { char *result; const char *p = message, *abbrev, *eol; int abbrev_len, oneline_len; if (!p) die ("Could not read commit message of %s", sha1_to_hex(commit->object.sha1)); while (*p && (*p != '\n' || p[1] != '\n')) p++; if (*p) { p += 2; for (eol = p + 1; *eol && *eol != '\n'; eol++) ; /* do nothing */ } else eol = p; abbrev = find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV); abbrev_len = strlen(abbrev); oneline_len = eol - p; result = xmalloc(abbrev_len + 5 + oneline_len); memcpy(result, abbrev, abbrev_len); memcpy(result + abbrev_len, "... ", 4); memcpy(result + abbrev_len + 4, p, oneline_len); result[abbrev_len + 4 + oneline_len] = '\0'; return result; }
static void output_commit_title(struct merge_options *o, struct commit *commit) { int i; flush_output(o); for (i = o->call_depth; i--;) fputs(" ", stdout); if (commit->util) printf("virtual %s\n", (char *)commit->util); else { printf("%s ", find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV)); if (parse_commit(commit) != 0) printf("(bad commit)\n"); else { const char *s; int len; for (s = commit->buffer; *s; s++) if (*s == '\n' && s[1] == '\n') { s += 2; break; } for (len = 0; s[len] && '\n' != s[len]; len++) ; /* do nothing */ printf("%.*s\n", len, s); } } }
static void wt_status_get_detached_from(struct wt_status_state *state) { struct grab_1st_switch_cbdata cb; struct commit *commit; unsigned char sha1[20]; char *ref = NULL; strbuf_init(&cb.buf, 0); if (for_each_reflog_ent_reverse("HEAD", grab_1st_switch, &cb) <= 0) { strbuf_release(&cb.buf); return; } if (dwim_ref(cb.buf.buf, cb.buf.len, sha1, &ref) == 1 && /* sha1 is a commit? match without further lookup */ (!hashcmp(cb.nsha1, sha1) || /* perhaps sha1 is a tag, try to dereference to a commit */ ((commit = lookup_commit_reference_gently(sha1, 1)) != NULL && !hashcmp(cb.nsha1, commit->object.sha1)))) { int ofs; if (!prefixcmp(ref, "refs/tags/")) ofs = strlen("refs/tags/"); else if (!prefixcmp(ref, "refs/remotes/")) ofs = strlen("refs/remotes/"); else ofs = 0; state->detached_from = xstrdup(ref + ofs); } else state->detached_from = xstrdup(find_unique_abbrev(cb.nsha1, DEFAULT_ABBREV)); hashcpy(state->detached_sha1, cb.nsha1); free(ref); strbuf_release(&cb.buf); }
/* * Extract branch information from rebase/bisect */ static char *read_and_strip_branch(const char *path) { struct strbuf sb = STRBUF_INIT; unsigned char sha1[20]; if (strbuf_read_file(&sb, git_path("%s", path), 0) <= 0) goto got_nothing; while (&sb.len && sb.buf[sb.len - 1] == '\n') strbuf_setlen(&sb, sb.len - 1); if (!sb.len) goto got_nothing; if (!prefixcmp(sb.buf, "refs/heads/")) strbuf_remove(&sb,0, strlen("refs/heads/")); else if (!prefixcmp(sb.buf, "refs/")) ; else if (!get_sha1_hex(sb.buf, sha1)) { const char *abbrev; abbrev = find_unique_abbrev(sha1, DEFAULT_ABBREV); strbuf_reset(&sb); strbuf_addstr(&sb, abbrev); } else if (!strcmp(sb.buf, "detached HEAD")) /* rebase */ goto got_nothing; else /* bisect */ ; return strbuf_detach(&sb, NULL); got_nothing: strbuf_release(&sb); return NULL; }
static void show_worktree(struct worktree *wt, int path_maxlen, int abbrev_len) { struct strbuf sb = STRBUF_INIT; int cur_path_len = strlen(wt->path); int path_adj = cur_path_len - utf8_strwidth(wt->path); strbuf_addf(&sb, "%-*s ", 1 + path_maxlen + path_adj, wt->path); if (wt->is_bare) strbuf_addstr(&sb, "(bare)"); else { strbuf_addf(&sb, "%-*s ", abbrev_len, find_unique_abbrev(wt->head_oid.hash, DEFAULT_ABBREV)); if (wt->is_detached) strbuf_addstr(&sb, "(detached HEAD)"); else if (wt->head_ref) { char *ref = shorten_unambiguous_ref(wt->head_ref, 0); strbuf_addf(&sb, "[%s]", ref); free(ref); } else strbuf_addstr(&sb, "(error)"); } printf("%s\n", sb.buf); strbuf_release(&sb); }
static int delete_tag(const char *name, const char *ref, const unsigned char *sha1) { if (delete_ref(ref, sha1, 0)) return 1; printf(_("Deleted tag '%s' (was %s)\n"), name, find_unique_abbrev(sha1, DEFAULT_ABBREV)); return 0; }
static void show_parents(struct commit *commit, int abbrev, FILE *file) { struct commit_list *p; for (p = commit->parents; p ; p = p->next) { struct commit *parent = p->item; fprintf(file, " %s", find_unique_abbrev(parent->object.oid.hash, abbrev)); } }
static void show_parents(struct commit *commit, int abbrev) { struct commit_list *p; for (p = commit->parents; p ; p = p->next) { struct commit *parent = p->item; printf(" %s", find_unique_abbrev(parent->object.sha1, abbrev)); } }
static void show_one(const char *refname, const unsigned char *sha1) { const char *hex = find_unique_abbrev(sha1, abbrev); if (hash_only) printf("%s\n", hex); else printf("%s %s\n", hex, refname); }
static int update_auto_abbrev(int auto_abbrev, struct blame_origin *suspect) { const char *uniq = find_unique_abbrev(suspect->commit->object.oid.hash, auto_abbrev); int len = strlen(uniq); if (auto_abbrev < len) return len; return auto_abbrev; }
static void print_ref_item(struct ref_item *item, int maxwidth, int verbose, int abbrev, int current) { char c; int color; struct commit *commit = item->commit; if (!matches_merge_filter(commit)) return; switch (item->kind) { case REF_LOCAL_BRANCH: color = COLOR_BRANCH_LOCAL; break; case REF_REMOTE_BRANCH: color = COLOR_BRANCH_REMOTE; break; default: color = COLOR_BRANCH_PLAIN; break; } c = ' '; if (current) { c = '*'; color = COLOR_BRANCH_CURRENT; } if (verbose) { struct strbuf subject = STRBUF_INIT, stat = STRBUF_INIT; const char *sub = " **** invalid ref ****"; commit = item->commit; if (commit && !parse_commit(commit)) { pretty_print_commit(CMIT_FMT_ONELINE, commit, &subject, 0, NULL, NULL, 0, 0); sub = subject.buf; } if (item->kind == REF_LOCAL_BRANCH) fill_tracking_info(&stat, item->name); printf("%c %s%-*s%s %s %s%s\n", c, branch_get_color(color), maxwidth, item->name, branch_get_color(COLOR_BRANCH_RESET), find_unique_abbrev(item->commit->object.sha1, abbrev), stat.buf, sub); strbuf_release(&stat); strbuf_release(&subject); } else { printf("%c %s%s%s\n", c, branch_get_color(color), item->name, branch_get_color(COLOR_BRANCH_RESET)); } }
static void suggest_reattach(struct commit *commit, struct rev_info *revs) { struct commit *c, *last = NULL; struct strbuf sb = STRBUF_INIT; int lost = 0; while ((c = get_revision(revs)) != NULL) { if (lost < ORPHAN_CUTOFF) describe_one_orphan(&sb, c); last = c; lost++; } if (ORPHAN_CUTOFF < lost) { int more = lost - ORPHAN_CUTOFF; if (more == 1) describe_one_orphan(&sb, last); else strbuf_addf(&sb, _(" ... and %d more.\n"), more); } fprintf(stderr, Q_( /* The singular version */ "Warning: you are leaving %d commit behind, " "not connected to\n" "any of your branches:\n\n" "%s\n", /* The plural version */ "Warning: you are leaving %d commits behind, " "not connected to\n" "any of your branches:\n\n" "%s\n", /* Give ngettext() the count */ lost), lost, sb.buf); strbuf_release(&sb); if (advice_detached_head) fprintf(stderr, Q_( /* The singular version */ "If you want to keep it by creating a new branch, " "this may be a good time\nto do so with:\n\n" " git branch <new-branch-name> %s\n\n", /* The plural version */ "If you want to keep them by creating a new branch, " "this may be a good time\nto do so with:\n\n" " git branch <new-branch-name> %s\n\n", /* Give ngettext() the count */ lost), find_unique_abbrev(&commit->object.oid, DEFAULT_ABBREV)); }
static int get_message(const char *raw_message, struct commit_message *out) { const char *encoding; const char *p, *abbrev, *eol; char *q; int abbrev_len, oneline_len; if (!raw_message) return -1; encoding = get_encoding(raw_message); if (!encoding) encoding = "UTF-8"; if (!git_commit_encoding) git_commit_encoding = "UTF-8"; out->reencoded_message = NULL; out->message = raw_message; if (strcmp(encoding, git_commit_encoding)) out->reencoded_message = reencode_string(raw_message, git_commit_encoding, encoding); if (out->reencoded_message) out->message = out->reencoded_message; abbrev = find_unique_abbrev(commit->object.sha1, DEFAULT_ABBREV); abbrev_len = strlen(abbrev); /* Find beginning and end of commit subject. */ p = out->message; while (*p && (*p != '\n' || p[1] != '\n')) p++; if (*p) { p += 2; for (eol = p + 1; *eol && *eol != '\n'; eol++) ; /* do nothing */ } else eol = p; oneline_len = eol - p; out->parent_label = xmalloc(strlen("parent of ") + abbrev_len + strlen("... ") + oneline_len + 1); q = out->parent_label; q = mempcpy(q, "parent of ", strlen("parent of ")); out->label = q; q = mempcpy(q, abbrev, abbrev_len); q = mempcpy(q, "... ", strlen("... ")); out->subject = q; q = mempcpy(q, p, oneline_len); *q = '\0'; return 0; }
static int grab_objectname(const char *name, const unsigned char *sha1, struct atom_value *v) { if (!strcmp(name, "objectname")) { char *s = xmalloc(41); strcpy(s, sha1_to_hex(sha1)); v->s = s; return 1; } if (!strcmp(name, "objectname:short")) { v->s = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV)); return 1; } return 0; }
static void measure_widths(struct worktree **wt, int *abbrev, int *maxlen) { int i; for (i = 0; wt[i]; i++) { int sha1_len; int path_len = strlen(wt[i]->path); if (path_len > *maxlen) *maxlen = path_len; sha1_len = strlen(find_unique_abbrev(wt[i]->head_oid.hash, *abbrev)); if (sha1_len > *abbrev) *abbrev = sha1_len; } }
static int format_todo(struct strbuf *buf, struct commit_list *todo_list, struct replay_opts *opts) { struct commit_list *cur = NULL; struct commit_message msg = { NULL, NULL, NULL, NULL, NULL }; const char *sha1_abbrev = NULL; const char *action_str = opts->action == REVERT ? "revert" : "pick"; for (cur = todo_list; cur; cur = cur->next) { sha1_abbrev = find_unique_abbrev(cur->item->object.sha1, DEFAULT_ABBREV); if (get_message(cur->item, &msg)) return error(_("Cannot get commit message for %s"), sha1_abbrev); strbuf_addf(buf, "%s %s %s\n", action_str, sha1_abbrev, msg.subject); } return 0; }
static int get_message(struct commit *commit, struct commit_message *out) { const char *abbrev, *subject; int subject_len; out->message = logmsg_reencode(commit, NULL, get_commit_output_encoding()); abbrev = find_unique_abbrev(commit->object.oid.hash, DEFAULT_ABBREV); subject_len = find_commit_subject(out->message, &subject); out->subject = xmemdupz(subject, subject_len); out->label = xstrfmt("%s... %s", abbrev, out->subject); out->parent_label = xstrfmt("parent of %s", out->label); return 0; }
static void emit_blame_entry_hash(struct blame_entry *ent) { struct blame_origin *suspect = ent->suspect; struct object_id *oid = &suspect->commit->object.oid; unsigned long line = 0; char *detail = emit_suspect_detail(suspect); html("<span class='sha1'>"); cgit_commit_link(find_unique_abbrev(oid->hash, DEFAULT_ABBREV), detail, NULL, ctx.qry.head, oid_to_hex(oid), suspect->path); html("</span>"); free(detail); while (line++ < ent->num_lines) html("\n"); }