2007-07-14 23:14:45 +00:00
|
|
|
#include "builtin.h"
|
2006-09-15 20:30:02 +00:00
|
|
|
#include "cache.h"
|
|
|
|
#include "refs.h"
|
|
|
|
#include "object.h"
|
|
|
|
#include "tag.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "tree.h"
|
|
|
|
#include "blob.h"
|
|
|
|
#include "quote.h"
|
2007-10-13 18:40:46 +00:00
|
|
|
#include "parse-options.h"
|
2009-04-07 07:09:39 +00:00
|
|
|
#include "remote.h"
|
2013-11-18 17:39:12 +00:00
|
|
|
#include "color.h"
|
2006-09-15 20:30:02 +00:00
|
|
|
|
|
|
|
/* Quoting styles */
|
|
|
|
#define QUOTE_NONE 0
|
|
|
|
#define QUOTE_SHELL 1
|
|
|
|
#define QUOTE_PERL 2
|
2007-12-06 12:24:39 +00:00
|
|
|
#define QUOTE_PYTHON 4
|
|
|
|
#define QUOTE_TCL 8
|
2006-09-15 20:30:02 +00:00
|
|
|
|
|
|
|
typedef enum { FIELD_STR, FIELD_ULONG, FIELD_TIME } cmp_type;
|
|
|
|
|
|
|
|
struct atom_value {
|
|
|
|
const char *s;
|
|
|
|
unsigned long ul; /* used for sorting when not FIELD_STR */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ref_sort {
|
|
|
|
struct ref_sort *next;
|
|
|
|
int atom; /* index into used_atom array */
|
|
|
|
unsigned reverse : 1;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct refinfo {
|
|
|
|
char *refname;
|
|
|
|
unsigned char objectname[20];
|
2010-02-13 19:57:08 +00:00
|
|
|
int flag;
|
|
|
|
const char *symref;
|
2006-09-15 20:30:02 +00:00
|
|
|
struct atom_value *value;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
const char *name;
|
|
|
|
cmp_type cmp_type;
|
|
|
|
} valid_atom[] = {
|
|
|
|
{ "refname" },
|
|
|
|
{ "objecttype" },
|
|
|
|
{ "objectsize", FIELD_ULONG },
|
|
|
|
{ "objectname" },
|
|
|
|
{ "tree" },
|
2007-10-02 22:09:41 +00:00
|
|
|
{ "parent" },
|
2006-09-15 20:30:02 +00:00
|
|
|
{ "numparent", FIELD_ULONG },
|
|
|
|
{ "object" },
|
|
|
|
{ "type" },
|
|
|
|
{ "tag" },
|
|
|
|
{ "author" },
|
|
|
|
{ "authorname" },
|
|
|
|
{ "authoremail" },
|
|
|
|
{ "authordate", FIELD_TIME },
|
|
|
|
{ "committer" },
|
|
|
|
{ "committername" },
|
|
|
|
{ "committeremail" },
|
|
|
|
{ "committerdate", FIELD_TIME },
|
|
|
|
{ "tagger" },
|
|
|
|
{ "taggername" },
|
|
|
|
{ "taggeremail" },
|
|
|
|
{ "taggerdate", FIELD_TIME },
|
2006-10-28 20:33:46 +00:00
|
|
|
{ "creator" },
|
|
|
|
{ "creatordate", FIELD_TIME },
|
2006-09-15 20:30:02 +00:00
|
|
|
{ "subject" },
|
|
|
|
{ "body" },
|
|
|
|
{ "contents" },
|
2011-09-07 17:46:08 +00:00
|
|
|
{ "contents:subject" },
|
|
|
|
{ "contents:body" },
|
|
|
|
{ "contents:signature" },
|
2009-04-07 07:09:39 +00:00
|
|
|
{ "upstream" },
|
2010-02-13 19:57:08 +00:00
|
|
|
{ "symref" },
|
2010-02-13 20:05:44 +00:00
|
|
|
{ "flag" },
|
2013-11-18 17:39:10 +00:00
|
|
|
{ "HEAD" },
|
2013-11-18 17:39:12 +00:00
|
|
|
{ "color" },
|
2006-09-15 20:30:02 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* An atom is a valid field atom listed above, possibly prefixed with
|
|
|
|
* a "*" to denote deref_tag().
|
|
|
|
*
|
|
|
|
* We parse given format string and sort specifiers, and make a list
|
|
|
|
* of properties that we need to extract out of objects. refinfo
|
|
|
|
* structure will hold an array of values extracted that can be
|
|
|
|
* indexed with the "atom number", which is an index into this
|
|
|
|
* array.
|
|
|
|
*/
|
|
|
|
static const char **used_atom;
|
|
|
|
static cmp_type *used_atom_type;
|
2013-12-30 16:28:55 +00:00
|
|
|
static int used_atom_cnt, need_tagged, need_symref;
|
2013-11-18 17:39:13 +00:00
|
|
|
static int need_color_reset_at_eol;
|
2006-09-15 20:30:02 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Used to parse format string and sort specifiers
|
|
|
|
*/
|
|
|
|
static int parse_atom(const char *atom, const char *ep)
|
|
|
|
{
|
|
|
|
const char *sp;
|
|
|
|
int i, at;
|
|
|
|
|
|
|
|
sp = atom;
|
|
|
|
if (*sp == '*' && sp < ep)
|
|
|
|
sp++; /* deref */
|
|
|
|
if (ep <= sp)
|
|
|
|
die("malformed field name: %.*s", (int)(ep-atom), atom);
|
|
|
|
|
|
|
|
/* Do we have the atom already used elsewhere? */
|
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
|
|
|
int len = strlen(used_atom[i]);
|
|
|
|
if (len == ep - atom && !memcmp(used_atom[i], atom, len))
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Is the atom a valid one? */
|
|
|
|
for (i = 0; i < ARRAY_SIZE(valid_atom); i++) {
|
|
|
|
int len = strlen(valid_atom[i].name);
|
2007-09-28 14:17:39 +00:00
|
|
|
/*
|
|
|
|
* If the atom name has a colon, strip it and everything after
|
|
|
|
* it off - it specifies the format for this entry, and
|
|
|
|
* shouldn't be used for checking against the valid_atom
|
|
|
|
* table.
|
|
|
|
*/
|
|
|
|
const char *formatp = strchr(sp, ':');
|
2007-10-02 21:31:37 +00:00
|
|
|
if (!formatp || ep < formatp)
|
2007-09-28 14:17:39 +00:00
|
|
|
formatp = ep;
|
|
|
|
if (len == formatp - sp && !memcmp(valid_atom[i].name, sp, len))
|
2006-09-15 20:30:02 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ARRAY_SIZE(valid_atom) <= i)
|
|
|
|
die("unknown field name: %.*s", (int)(ep-atom), atom);
|
|
|
|
|
|
|
|
/* Add it in, including the deref prefix */
|
|
|
|
at = used_atom_cnt;
|
|
|
|
used_atom_cnt++;
|
|
|
|
used_atom = xrealloc(used_atom,
|
|
|
|
(sizeof *used_atom) * used_atom_cnt);
|
|
|
|
used_atom_type = xrealloc(used_atom_type,
|
|
|
|
(sizeof(*used_atom_type) * used_atom_cnt));
|
2007-09-15 22:32:36 +00:00
|
|
|
used_atom[at] = xmemdupz(atom, ep - atom);
|
2006-09-15 20:30:02 +00:00
|
|
|
used_atom_type[at] = valid_atom[i].cmp_type;
|
2010-02-13 19:38:42 +00:00
|
|
|
if (*atom == '*')
|
|
|
|
need_tagged = 1;
|
2010-02-13 19:57:08 +00:00
|
|
|
if (!strcmp(used_atom[at], "symref"))
|
|
|
|
need_symref = 1;
|
2006-09-15 20:30:02 +00:00
|
|
|
return at;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In a format string, find the next occurrence of %(atom).
|
|
|
|
*/
|
|
|
|
static const char *find_next(const char *cp)
|
|
|
|
{
|
|
|
|
while (*cp) {
|
|
|
|
if (*cp == '%') {
|
2010-02-13 19:29:27 +00:00
|
|
|
/*
|
|
|
|
* %( is the start of an atom;
|
2007-02-04 04:49:16 +00:00
|
|
|
* %% is a quoted per-cent.
|
2006-09-15 20:30:02 +00:00
|
|
|
*/
|
|
|
|
if (cp[1] == '(')
|
|
|
|
return cp;
|
|
|
|
else if (cp[1] == '%')
|
|
|
|
cp++; /* skip over two % */
|
|
|
|
/* otherwise this is a singleton, literal % */
|
|
|
|
}
|
|
|
|
cp++;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure the format string is well formed, and parse out
|
|
|
|
* the used atoms.
|
|
|
|
*/
|
2007-10-13 18:40:46 +00:00
|
|
|
static int verify_format(const char *format)
|
2006-09-15 20:30:02 +00:00
|
|
|
{
|
|
|
|
const char *cp, *sp;
|
2013-11-18 17:39:13 +00:00
|
|
|
static const char color_reset[] = "color:reset";
|
|
|
|
|
|
|
|
need_color_reset_at_eol = 0;
|
2006-09-15 20:30:02 +00:00
|
|
|
for (cp = format; *cp && (sp = find_next(cp)); ) {
|
|
|
|
const char *ep = strchr(sp, ')');
|
2013-11-18 17:39:13 +00:00
|
|
|
int at;
|
|
|
|
|
2006-09-15 20:30:02 +00:00
|
|
|
if (!ep)
|
2008-02-24 23:16:04 +00:00
|
|
|
return error("malformed format string %s", sp);
|
2006-09-15 20:30:02 +00:00
|
|
|
/* sp points at "%(" and ep points at the closing ")" */
|
2013-11-18 17:39:13 +00:00
|
|
|
at = parse_atom(sp + 2, ep);
|
2006-09-15 20:30:02 +00:00
|
|
|
cp = ep + 1;
|
2013-11-18 17:39:13 +00:00
|
|
|
|
|
|
|
if (!memcmp(used_atom[at], "color:", 6))
|
|
|
|
need_color_reset_at_eol = !!strcmp(used_atom[at], color_reset);
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
2007-10-13 18:40:46 +00:00
|
|
|
return 0;
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given an object name, read the object data and size, and return a
|
|
|
|
* "struct object". If the object data we are returning is also borrowed
|
|
|
|
* by the "struct object" representation, set *eaten as well---it is a
|
|
|
|
* signal from parse_object_buffer to us not to free the buffer.
|
|
|
|
*/
|
|
|
|
static void *get_obj(const unsigned char *sha1, struct object **obj, unsigned long *sz, int *eaten)
|
|
|
|
{
|
2007-02-26 19:55:59 +00:00
|
|
|
enum object_type type;
|
|
|
|
void *buf = read_sha1_file(sha1, &type, sz);
|
2006-09-15 20:30:02 +00:00
|
|
|
|
|
|
|
if (buf)
|
|
|
|
*obj = parse_object_buffer(sha1, type, *sz, buf, eaten);
|
|
|
|
else
|
|
|
|
*obj = NULL;
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
2013-10-30 06:50:16 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2006-09-15 20:30:02 +00:00
|
|
|
/* 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"))
|
2007-02-26 19:55:58 +00:00
|
|
|
v->s = typename(obj->type);
|
2006-09-15 20:30:02 +00:00
|
|
|
else if (!strcmp(name, "objectsize")) {
|
|
|
|
char *s = xmalloc(40);
|
|
|
|
sprintf(s, "%lu", sz);
|
|
|
|
v->ul = sz;
|
|
|
|
v->s = s;
|
|
|
|
}
|
2013-10-30 06:50:16 +00:00
|
|
|
else if (deref)
|
|
|
|
grab_objectname(name, obj->sha1, v);
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* See grab_values */
|
|
|
|
static void grab_tag_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct tag *tag = (struct tag *) obj;
|
|
|
|
|
|
|
|
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, "tag"))
|
|
|
|
v->s = tag->tag;
|
2008-06-25 16:08:15 +00:00
|
|
|
else if (!strcmp(name, "type") && tag->tagged)
|
|
|
|
v->s = typename(tag->tagged->type);
|
|
|
|
else if (!strcmp(name, "object") && tag->tagged) {
|
|
|
|
char *s = xmalloc(41);
|
|
|
|
strcpy(s, sha1_to_hex(tag->tagged->sha1));
|
|
|
|
v->s = s;
|
|
|
|
}
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int num_parents(struct commit *commit)
|
|
|
|
{
|
|
|
|
struct commit_list *parents;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0, parents = commit->parents;
|
|
|
|
parents;
|
|
|
|
parents = parents->next)
|
|
|
|
i++;
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* See grab_values */
|
|
|
|
static void grab_commit_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct commit *commit = (struct commit *) obj;
|
|
|
|
|
|
|
|
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, "tree")) {
|
|
|
|
char *s = xmalloc(41);
|
|
|
|
strcpy(s, sha1_to_hex(commit->tree->object.sha1));
|
|
|
|
v->s = s;
|
|
|
|
}
|
|
|
|
if (!strcmp(name, "numparent")) {
|
|
|
|
char *s = xmalloc(40);
|
2007-10-02 22:09:41 +00:00
|
|
|
v->ul = num_parents(commit);
|
2006-09-15 20:30:02 +00:00
|
|
|
sprintf(s, "%lu", v->ul);
|
|
|
|
v->s = s;
|
|
|
|
}
|
|
|
|
else if (!strcmp(name, "parent")) {
|
|
|
|
int num = num_parents(commit);
|
|
|
|
int i;
|
|
|
|
struct commit_list *parents;
|
2007-10-02 22:09:41 +00:00
|
|
|
char *s = xmalloc(41 * num + 1);
|
2006-09-15 20:30:02 +00:00
|
|
|
v->s = s;
|
|
|
|
for (i = 0, parents = commit->parents;
|
|
|
|
parents;
|
2007-10-02 22:09:41 +00:00
|
|
|
parents = parents->next, i = i + 41) {
|
2006-09-15 20:30:02 +00:00
|
|
|
struct commit *parent = parents->item;
|
|
|
|
strcpy(s+i, sha1_to_hex(parent->object.sha1));
|
|
|
|
if (parents->next)
|
|
|
|
s[i+40] = ' ';
|
|
|
|
}
|
2007-10-02 22:09:41 +00:00
|
|
|
if (!i)
|
|
|
|
*s = '\0';
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static const char *find_wholine(const char *who, int wholen, const char *buf, unsigned long sz)
|
|
|
|
{
|
|
|
|
const char *eol;
|
|
|
|
while (*buf) {
|
|
|
|
if (!strncmp(buf, who, wholen) &&
|
|
|
|
buf[wholen] == ' ')
|
|
|
|
return buf + wholen + 1;
|
|
|
|
eol = strchr(buf, '\n');
|
|
|
|
if (!eol)
|
|
|
|
return "";
|
|
|
|
eol++;
|
2007-11-12 04:37:25 +00:00
|
|
|
if (*eol == '\n')
|
2006-09-15 20:30:02 +00:00
|
|
|
return ""; /* end of header */
|
|
|
|
buf = eol;
|
|
|
|
}
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2007-03-07 01:44:17 +00:00
|
|
|
static const char *copy_line(const char *buf)
|
2006-09-15 20:30:02 +00:00
|
|
|
{
|
2008-09-27 22:24:36 +00:00
|
|
|
const char *eol = strchrnul(buf, '\n');
|
2007-09-15 22:32:36 +00:00
|
|
|
return xmemdupz(buf, eol - buf);
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
|
|
|
|
2007-03-07 01:44:17 +00:00
|
|
|
static const char *copy_name(const char *buf)
|
2006-09-15 20:30:02 +00:00
|
|
|
{
|
2007-09-15 22:32:36 +00:00
|
|
|
const char *cp;
|
2007-09-19 08:52:59 +00:00
|
|
|
for (cp = buf; *cp && *cp != '\n'; cp++) {
|
2007-09-15 22:32:36 +00:00
|
|
|
if (!strncmp(cp, " <", 2))
|
|
|
|
return xmemdupz(buf, cp - buf);
|
|
|
|
}
|
|
|
|
return "";
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
|
|
|
|
2007-03-07 01:44:17 +00:00
|
|
|
static const char *copy_email(const char *buf)
|
2006-09-15 20:30:02 +00:00
|
|
|
{
|
|
|
|
const char *email = strchr(buf, '<');
|
2009-05-18 17:58:11 +00:00
|
|
|
const char *eoemail;
|
|
|
|
if (!email)
|
|
|
|
return "";
|
|
|
|
eoemail = strchr(email, '>');
|
|
|
|
if (!eoemail)
|
2006-09-15 20:30:02 +00:00
|
|
|
return "";
|
2007-09-15 22:32:36 +00:00
|
|
|
return xmemdupz(email, eoemail + 1 - email);
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
|
|
|
|
2011-09-07 17:44:56 +00:00
|
|
|
static char *copy_subject(const char *buf, unsigned long len)
|
|
|
|
{
|
|
|
|
char *r = xmemdupz(buf, len);
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
if (r[i] == '\n')
|
|
|
|
r[i] = ' ';
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2007-09-28 14:17:45 +00:00
|
|
|
static void grab_date(const char *buf, struct atom_value *v, const char *atomname)
|
2006-09-15 20:30:02 +00:00
|
|
|
{
|
|
|
|
const char *eoemail = strstr(buf, "> ");
|
|
|
|
char *zone;
|
|
|
|
unsigned long timestamp;
|
|
|
|
long tz;
|
2007-09-28 14:17:45 +00:00
|
|
|
enum date_mode date_mode = DATE_NORMAL;
|
|
|
|
const char *formatp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We got here because atomname ends in "date" or "date<something>";
|
|
|
|
* it's not possible that <something> is not ":<format>" because
|
|
|
|
* parse_atom() wouldn't have allowed it, so we can assume that no
|
|
|
|
* ":" means no format is specified, and use the default.
|
|
|
|
*/
|
|
|
|
formatp = strchr(atomname, ':');
|
|
|
|
if (formatp != NULL) {
|
|
|
|
formatp++;
|
|
|
|
date_mode = parse_date_format(formatp);
|
|
|
|
}
|
2006-09-15 20:30:02 +00:00
|
|
|
|
|
|
|
if (!eoemail)
|
|
|
|
goto bad;
|
|
|
|
timestamp = strtoul(eoemail + 2, &zone, 10);
|
|
|
|
if (timestamp == ULONG_MAX)
|
|
|
|
goto bad;
|
|
|
|
tz = strtol(zone, NULL, 10);
|
|
|
|
if ((tz == LONG_MIN || tz == LONG_MAX) && errno == ERANGE)
|
|
|
|
goto bad;
|
2007-09-28 14:17:45 +00:00
|
|
|
v->s = xstrdup(show_date(timestamp, tz, date_mode));
|
2006-09-15 20:30:02 +00:00
|
|
|
v->ul = timestamp;
|
|
|
|
return;
|
|
|
|
bad:
|
|
|
|
v->s = "";
|
|
|
|
v->ul = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* See grab_values */
|
|
|
|
static void grab_person(const char *who, struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int wholen = strlen(who);
|
|
|
|
const char *wholine = NULL;
|
|
|
|
|
|
|
|
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 (strncmp(who, name, wholen))
|
|
|
|
continue;
|
|
|
|
if (name[wholen] != 0 &&
|
|
|
|
strcmp(name + wholen, "name") &&
|
|
|
|
strcmp(name + wholen, "email") &&
|
2013-11-30 20:55:40 +00:00
|
|
|
!starts_with(name + wholen, "date"))
|
2006-09-15 20:30:02 +00:00
|
|
|
continue;
|
|
|
|
if (!wholine)
|
|
|
|
wholine = find_wholine(who, wholen, buf, sz);
|
|
|
|
if (!wholine)
|
|
|
|
return; /* no point looking for it */
|
|
|
|
if (name[wholen] == 0)
|
|
|
|
v->s = copy_line(wholine);
|
|
|
|
else if (!strcmp(name + wholen, "name"))
|
|
|
|
v->s = copy_name(wholine);
|
|
|
|
else if (!strcmp(name + wholen, "email"))
|
|
|
|
v->s = copy_email(wholine);
|
2013-11-30 20:55:40 +00:00
|
|
|
else if (starts_with(name + wholen, "date"))
|
2007-09-28 14:17:45 +00:00
|
|
|
grab_date(wholine, v, name);
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
2006-10-28 20:33:46 +00:00
|
|
|
|
2010-02-13 19:29:27 +00:00
|
|
|
/*
|
|
|
|
* For a tag or a commit object, if "creator" or "creatordate" is
|
2006-10-28 20:33:46 +00:00
|
|
|
* requested, do something special.
|
|
|
|
*/
|
|
|
|
if (strcmp(who, "tagger") && strcmp(who, "committer"))
|
|
|
|
return; /* "author" for commit object is not wanted */
|
|
|
|
if (!wholine)
|
|
|
|
wholine = find_wholine(who, wholen, buf, sz);
|
|
|
|
if (!wholine)
|
|
|
|
return;
|
|
|
|
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++;
|
|
|
|
|
2013-11-30 20:55:40 +00:00
|
|
|
if (starts_with(name, "creatordate"))
|
2007-09-28 14:17:45 +00:00
|
|
|
grab_date(wholine, v, name);
|
2006-10-28 20:33:46 +00:00
|
|
|
else if (!strcmp(name, "creator"))
|
|
|
|
v->s = copy_line(wholine);
|
|
|
|
}
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
|
|
|
|
for-each-ref: refactor subject and body placeholder parsing
The find_subpos function was a little hard to use, as well
as to read. It would sometimes write into the subject and
body pointers, and sometimes not. The body pointer sometimes
could be compared to subject, and sometimes not. When
actually duplicating the subject, the caller was forced to
figure out again how long the subject is (which is not too
big a deal when the subject is a single line, but hard to
extend).
The refactoring makes the function more straightforward, both
to read and to use. We will always put something into the
subject and body pointers, and we return explicit lengths
for them, too.
This lays the groundwork both for more complex subject
parsing (e.g., multiline), as well as splitting the body
into subparts (like the text versus the signature).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-09-07 17:44:07 +00:00
|
|
|
static void find_subpos(const char *buf, unsigned long sz,
|
|
|
|
const char **sub, unsigned long *sublen,
|
2011-09-07 17:46:08 +00:00
|
|
|
const char **body, unsigned long *bodylen,
|
|
|
|
unsigned long *nonsiglen,
|
|
|
|
const char **sig, unsigned long *siglen)
|
2006-09-15 20:30:02 +00:00
|
|
|
{
|
for-each-ref: refactor subject and body placeholder parsing
The find_subpos function was a little hard to use, as well
as to read. It would sometimes write into the subject and
body pointers, and sometimes not. The body pointer sometimes
could be compared to subject, and sometimes not. When
actually duplicating the subject, the caller was forced to
figure out again how long the subject is (which is not too
big a deal when the subject is a single line, but hard to
extend).
The refactoring makes the function more straightforward, both
to read and to use. We will always put something into the
subject and body pointers, and we return explicit lengths
for them, too.
This lays the groundwork both for more complex subject
parsing (e.g., multiline), as well as splitting the body
into subparts (like the text versus the signature).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-09-07 17:44:07 +00:00
|
|
|
const char *eol;
|
|
|
|
/* skip past header until we hit empty line */
|
|
|
|
while (*buf && *buf != '\n') {
|
|
|
|
eol = strchrnul(buf, '\n');
|
|
|
|
if (*eol)
|
|
|
|
eol++;
|
|
|
|
buf = eol;
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
for-each-ref: refactor subject and body placeholder parsing
The find_subpos function was a little hard to use, as well
as to read. It would sometimes write into the subject and
body pointers, and sometimes not. The body pointer sometimes
could be compared to subject, and sometimes not. When
actually duplicating the subject, the caller was forced to
figure out again how long the subject is (which is not too
big a deal when the subject is a single line, but hard to
extend).
The refactoring makes the function more straightforward, both
to read and to use. We will always put something into the
subject and body pointers, and we return explicit lengths
for them, too.
This lays the groundwork both for more complex subject
parsing (e.g., multiline), as well as splitting the body
into subparts (like the text versus the signature).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-09-07 17:44:07 +00:00
|
|
|
/* skip any empty lines */
|
2006-09-15 20:30:02 +00:00
|
|
|
while (*buf == '\n')
|
|
|
|
buf++;
|
for-each-ref: refactor subject and body placeholder parsing
The find_subpos function was a little hard to use, as well
as to read. It would sometimes write into the subject and
body pointers, and sometimes not. The body pointer sometimes
could be compared to subject, and sometimes not. When
actually duplicating the subject, the caller was forced to
figure out again how long the subject is (which is not too
big a deal when the subject is a single line, but hard to
extend).
The refactoring makes the function more straightforward, both
to read and to use. We will always put something into the
subject and body pointers, and we return explicit lengths
for them, too.
This lays the groundwork both for more complex subject
parsing (e.g., multiline), as well as splitting the body
into subparts (like the text versus the signature).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-09-07 17:44:07 +00:00
|
|
|
|
2011-09-07 17:46:08 +00:00
|
|
|
/* parse signature first; we might not even have a subject line */
|
|
|
|
*sig = buf + parse_signature(buf, strlen(buf));
|
|
|
|
*siglen = strlen(*sig);
|
|
|
|
|
for-each-ref: refactor subject and body placeholder parsing
The find_subpos function was a little hard to use, as well
as to read. It would sometimes write into the subject and
body pointers, and sometimes not. The body pointer sometimes
could be compared to subject, and sometimes not. When
actually duplicating the subject, the caller was forced to
figure out again how long the subject is (which is not too
big a deal when the subject is a single line, but hard to
extend).
The refactoring makes the function more straightforward, both
to read and to use. We will always put something into the
subject and body pointers, and we return explicit lengths
for them, too.
This lays the groundwork both for more complex subject
parsing (e.g., multiline), as well as splitting the body
into subparts (like the text versus the signature).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-09-07 17:44:07 +00:00
|
|
|
/* subject is first non-empty line */
|
|
|
|
*sub = buf;
|
2011-09-07 17:44:56 +00:00
|
|
|
/* subject goes to first empty line */
|
2011-09-07 17:46:08 +00:00
|
|
|
while (buf < *sig && *buf && *buf != '\n') {
|
2011-09-07 17:44:56 +00:00
|
|
|
eol = strchrnul(buf, '\n');
|
|
|
|
if (*eol)
|
|
|
|
eol++;
|
|
|
|
buf = eol;
|
|
|
|
}
|
|
|
|
*sublen = buf - *sub;
|
|
|
|
/* drop trailing newline, if present */
|
|
|
|
if (*sublen && (*sub)[*sublen - 1] == '\n')
|
|
|
|
*sublen -= 1;
|
for-each-ref: refactor subject and body placeholder parsing
The find_subpos function was a little hard to use, as well
as to read. It would sometimes write into the subject and
body pointers, and sometimes not. The body pointer sometimes
could be compared to subject, and sometimes not. When
actually duplicating the subject, the caller was forced to
figure out again how long the subject is (which is not too
big a deal when the subject is a single line, but hard to
extend).
The refactoring makes the function more straightforward, both
to read and to use. We will always put something into the
subject and body pointers, and we return explicit lengths
for them, too.
This lays the groundwork both for more complex subject
parsing (e.g., multiline), as well as splitting the body
into subparts (like the text versus the signature).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-09-07 17:44:07 +00:00
|
|
|
|
|
|
|
/* skip any empty lines */
|
2006-09-15 20:30:02 +00:00
|
|
|
while (*buf == '\n')
|
for-each-ref: refactor subject and body placeholder parsing
The find_subpos function was a little hard to use, as well
as to read. It would sometimes write into the subject and
body pointers, and sometimes not. The body pointer sometimes
could be compared to subject, and sometimes not. When
actually duplicating the subject, the caller was forced to
figure out again how long the subject is (which is not too
big a deal when the subject is a single line, but hard to
extend).
The refactoring makes the function more straightforward, both
to read and to use. We will always put something into the
subject and body pointers, and we return explicit lengths
for them, too.
This lays the groundwork both for more complex subject
parsing (e.g., multiline), as well as splitting the body
into subparts (like the text versus the signature).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-09-07 17:44:07 +00:00
|
|
|
buf++;
|
2006-09-15 20:30:02 +00:00
|
|
|
*body = buf;
|
for-each-ref: refactor subject and body placeholder parsing
The find_subpos function was a little hard to use, as well
as to read. It would sometimes write into the subject and
body pointers, and sometimes not. The body pointer sometimes
could be compared to subject, and sometimes not. When
actually duplicating the subject, the caller was forced to
figure out again how long the subject is (which is not too
big a deal when the subject is a single line, but hard to
extend).
The refactoring makes the function more straightforward, both
to read and to use. We will always put something into the
subject and body pointers, and we return explicit lengths
for them, too.
This lays the groundwork both for more complex subject
parsing (e.g., multiline), as well as splitting the body
into subparts (like the text versus the signature).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-09-07 17:44:07 +00:00
|
|
|
*bodylen = strlen(buf);
|
2011-09-07 17:46:08 +00:00
|
|
|
*nonsiglen = *sig - buf;
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* See grab_values */
|
|
|
|
static void grab_sub_body_contents(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
|
|
|
|
{
|
|
|
|
int i;
|
2011-09-07 17:46:08 +00:00
|
|
|
const char *subpos = NULL, *bodypos = NULL, *sigpos = NULL;
|
|
|
|
unsigned long sublen = 0, bodylen = 0, nonsiglen = 0, siglen = 0;
|
2006-09-15 20:30:02 +00:00
|
|
|
|
|
|
|
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, "subject") &&
|
|
|
|
strcmp(name, "body") &&
|
2011-09-07 17:46:08 +00:00
|
|
|
strcmp(name, "contents") &&
|
|
|
|
strcmp(name, "contents:subject") &&
|
|
|
|
strcmp(name, "contents:body") &&
|
|
|
|
strcmp(name, "contents:signature"))
|
2006-09-15 20:30:02 +00:00
|
|
|
continue;
|
|
|
|
if (!subpos)
|
for-each-ref: refactor subject and body placeholder parsing
The find_subpos function was a little hard to use, as well
as to read. It would sometimes write into the subject and
body pointers, and sometimes not. The body pointer sometimes
could be compared to subject, and sometimes not. When
actually duplicating the subject, the caller was forced to
figure out again how long the subject is (which is not too
big a deal when the subject is a single line, but hard to
extend).
The refactoring makes the function more straightforward, both
to read and to use. We will always put something into the
subject and body pointers, and we return explicit lengths
for them, too.
This lays the groundwork both for more complex subject
parsing (e.g., multiline), as well as splitting the body
into subparts (like the text versus the signature).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-09-07 17:44:07 +00:00
|
|
|
find_subpos(buf, sz,
|
|
|
|
&subpos, &sublen,
|
2011-09-07 17:46:08 +00:00
|
|
|
&bodypos, &bodylen, &nonsiglen,
|
|
|
|
&sigpos, &siglen);
|
2006-09-15 20:30:02 +00:00
|
|
|
|
|
|
|
if (!strcmp(name, "subject"))
|
2011-09-07 17:44:56 +00:00
|
|
|
v->s = copy_subject(subpos, sublen);
|
2011-09-07 17:46:08 +00:00
|
|
|
else if (!strcmp(name, "contents:subject"))
|
|
|
|
v->s = copy_subject(subpos, sublen);
|
2006-09-15 20:30:02 +00:00
|
|
|
else if (!strcmp(name, "body"))
|
for-each-ref: refactor subject and body placeholder parsing
The find_subpos function was a little hard to use, as well
as to read. It would sometimes write into the subject and
body pointers, and sometimes not. The body pointer sometimes
could be compared to subject, and sometimes not. When
actually duplicating the subject, the caller was forced to
figure out again how long the subject is (which is not too
big a deal when the subject is a single line, but hard to
extend).
The refactoring makes the function more straightforward, both
to read and to use. We will always put something into the
subject and body pointers, and we return explicit lengths
for them, too.
This lays the groundwork both for more complex subject
parsing (e.g., multiline), as well as splitting the body
into subparts (like the text versus the signature).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2011-09-07 17:44:07 +00:00
|
|
|
v->s = xmemdupz(bodypos, bodylen);
|
2011-09-07 17:46:08 +00:00
|
|
|
else if (!strcmp(name, "contents:body"))
|
|
|
|
v->s = xmemdupz(bodypos, nonsiglen);
|
|
|
|
else if (!strcmp(name, "contents:signature"))
|
|
|
|
v->s = xmemdupz(sigpos, siglen);
|
2006-09-15 20:30:02 +00:00
|
|
|
else if (!strcmp(name, "contents"))
|
2006-11-18 02:56:52 +00:00
|
|
|
v->s = xstrdup(subpos);
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-13 19:29:27 +00:00
|
|
|
/*
|
|
|
|
* We want to have empty print-string for field requests
|
2006-09-15 20:30:02 +00:00
|
|
|
* that do not apply (e.g. "authordate" for a tag object)
|
|
|
|
*/
|
|
|
|
static void fill_missing_values(struct atom_value *val)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
|
|
|
struct atom_value *v = &val[i];
|
|
|
|
if (v->s == NULL)
|
|
|
|
v->s = "";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* val is a list of atom_value to hold returned values. Extract
|
|
|
|
* the values for atoms in used_atom array out of (obj, buf, sz).
|
|
|
|
* when deref is false, (obj, buf, sz) is the object that is
|
|
|
|
* pointed at by the ref itself; otherwise it is the object the
|
|
|
|
* ref (which is a tag) refers to.
|
|
|
|
*/
|
|
|
|
static void grab_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
|
|
|
|
{
|
|
|
|
grab_common_values(val, deref, obj, buf, sz);
|
|
|
|
switch (obj->type) {
|
|
|
|
case OBJ_TAG:
|
|
|
|
grab_tag_values(val, deref, obj, buf, sz);
|
|
|
|
grab_sub_body_contents(val, deref, obj, buf, sz);
|
|
|
|
grab_person("tagger", val, deref, obj, buf, sz);
|
|
|
|
break;
|
|
|
|
case OBJ_COMMIT:
|
|
|
|
grab_commit_values(val, deref, obj, buf, sz);
|
|
|
|
grab_sub_body_contents(val, deref, obj, buf, sz);
|
|
|
|
grab_person("author", val, deref, obj, buf, sz);
|
|
|
|
grab_person("committer", val, deref, obj, buf, sz);
|
|
|
|
break;
|
|
|
|
case OBJ_TREE:
|
2010-06-04 09:32:11 +00:00
|
|
|
/* grab_tree_values(val, deref, obj, buf, sz); */
|
2006-09-15 20:30:02 +00:00
|
|
|
break;
|
|
|
|
case OBJ_BLOB:
|
2010-06-04 09:32:11 +00:00
|
|
|
/* grab_blob_values(val, deref, obj, buf, sz); */
|
2006-09-15 20:30:02 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
die("Eh? Object of type %d?", obj->type);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-02-13 20:05:44 +00:00
|
|
|
static inline char *copy_advance(char *dst, const char *src)
|
|
|
|
{
|
|
|
|
while (*src)
|
|
|
|
*dst++ = *src++;
|
|
|
|
return dst;
|
|
|
|
}
|
|
|
|
|
2006-09-15 20:30:02 +00:00
|
|
|
/*
|
|
|
|
* Parse the object referred by ref, and grab needed value.
|
|
|
|
*/
|
|
|
|
static void populate_value(struct refinfo *ref)
|
|
|
|
{
|
|
|
|
void *buf;
|
|
|
|
struct object *obj;
|
|
|
|
int eaten, i;
|
|
|
|
unsigned long size;
|
|
|
|
const unsigned char *tagged;
|
|
|
|
|
|
|
|
ref->value = xcalloc(sizeof(struct atom_value), used_atom_cnt);
|
|
|
|
|
2010-02-13 19:57:08 +00:00
|
|
|
if (need_symref && (ref->flag & REF_ISSYMREF) && !ref->symref) {
|
|
|
|
unsigned char unused1[20];
|
2011-12-13 14:17:48 +00:00
|
|
|
ref->symref = resolve_refdup(ref->refname, unused1, 1, NULL);
|
|
|
|
if (!ref->symref)
|
2010-02-13 19:57:08 +00:00
|
|
|
ref->symref = "";
|
|
|
|
}
|
|
|
|
|
2006-09-15 20:30:02 +00:00
|
|
|
/* Fill in specials first */
|
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
|
|
|
const char *name = used_atom[i];
|
|
|
|
struct atom_value *v = &ref->value[i];
|
2008-09-05 21:16:23 +00:00
|
|
|
int deref = 0;
|
2009-04-07 07:06:51 +00:00
|
|
|
const char *refname;
|
|
|
|
const char *formatp;
|
2013-11-18 17:39:11 +00:00
|
|
|
struct branch *branch = NULL;
|
2009-04-07 07:06:51 +00:00
|
|
|
|
2008-09-05 21:16:23 +00:00
|
|
|
if (*name == '*') {
|
|
|
|
deref = 1;
|
|
|
|
name++;
|
|
|
|
}
|
|
|
|
|
2013-11-30 20:55:40 +00:00
|
|
|
if (starts_with(name, "refname"))
|
2009-04-07 07:06:51 +00:00
|
|
|
refname = ref->refname;
|
2013-11-30 20:55:40 +00:00
|
|
|
else if (starts_with(name, "symref"))
|
2010-02-13 19:57:08 +00:00
|
|
|
refname = ref->symref ? ref->symref : "";
|
2013-11-30 20:55:40 +00:00
|
|
|
else if (starts_with(name, "upstream")) {
|
2009-04-07 07:09:39 +00:00
|
|
|
/* only local branches may have an upstream */
|
2013-11-30 20:55:40 +00:00
|
|
|
if (!starts_with(ref->refname, "refs/heads/"))
|
2009-04-07 07:09:39 +00:00
|
|
|
continue;
|
|
|
|
branch = branch_get(ref->refname + 11);
|
|
|
|
|
|
|
|
if (!branch || !branch->merge || !branch->merge[0] ||
|
|
|
|
!branch->merge[0]->dst)
|
|
|
|
continue;
|
|
|
|
refname = branch->merge[0]->dst;
|
2013-12-17 19:47:35 +00:00
|
|
|
} else if (starts_with(name, "color:")) {
|
2013-11-18 17:39:12 +00:00
|
|
|
char color[COLOR_MAXLEN] = "";
|
|
|
|
|
|
|
|
color_parse(name + 6, "--format", color);
|
|
|
|
v->s = xstrdup(color);
|
|
|
|
continue;
|
|
|
|
} else if (!strcmp(name, "flag")) {
|
2010-02-13 20:05:44 +00:00
|
|
|
char buf[256], *cp = buf;
|
|
|
|
if (ref->flag & REF_ISSYMREF)
|
|
|
|
cp = copy_advance(cp, ",symref");
|
|
|
|
if (ref->flag & REF_ISPACKED)
|
|
|
|
cp = copy_advance(cp, ",packed");
|
|
|
|
if (cp == buf)
|
|
|
|
v->s = "";
|
|
|
|
else {
|
|
|
|
*cp = '\0';
|
|
|
|
v->s = xstrdup(buf + 1);
|
|
|
|
}
|
|
|
|
continue;
|
2013-12-06 19:07:20 +00:00
|
|
|
} else if (!deref && grab_objectname(name, ref->objectname, v)) {
|
2013-10-30 06:50:16 +00:00
|
|
|
continue;
|
2013-11-18 17:39:10 +00:00
|
|
|
} else if (!strcmp(name, "HEAD")) {
|
|
|
|
const char *head;
|
|
|
|
unsigned char sha1[20];
|
2013-11-18 17:39:11 +00:00
|
|
|
|
2013-11-18 17:39:10 +00:00
|
|
|
head = resolve_ref_unsafe("HEAD", sha1, 1, NULL);
|
|
|
|
if (!strcmp(ref->refname, head))
|
|
|
|
v->s = "*";
|
|
|
|
else
|
|
|
|
v->s = " ";
|
|
|
|
continue;
|
|
|
|
} else
|
2009-04-07 07:06:51 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
formatp = strchr(name, ':');
|
|
|
|
if (formatp) {
|
2013-11-18 17:39:11 +00:00
|
|
|
int num_ours, num_theirs;
|
|
|
|
|
2009-04-07 07:06:51 +00:00
|
|
|
formatp++;
|
|
|
|
if (!strcmp(formatp, "short"))
|
2009-04-13 10:25:47 +00:00
|
|
|
refname = shorten_unambiguous_ref(refname,
|
|
|
|
warn_ambiguous_refs);
|
2013-11-18 17:39:11 +00:00
|
|
|
else if (!strcmp(formatp, "track") &&
|
2013-12-17 19:47:35 +00:00
|
|
|
starts_with(name, "upstream")) {
|
2013-11-18 17:39:11 +00:00
|
|
|
char buf[40];
|
|
|
|
|
|
|
|
stat_tracking_info(branch, &num_ours, &num_theirs);
|
|
|
|
if (!num_ours && !num_theirs)
|
|
|
|
v->s = "";
|
|
|
|
else if (!num_ours) {
|
|
|
|
sprintf(buf, "[behind %d]", num_theirs);
|
|
|
|
v->s = xstrdup(buf);
|
|
|
|
} else if (!num_theirs) {
|
|
|
|
sprintf(buf, "[ahead %d]", num_ours);
|
|
|
|
v->s = xstrdup(buf);
|
|
|
|
} else {
|
|
|
|
sprintf(buf, "[ahead %d, behind %d]",
|
|
|
|
num_ours, num_theirs);
|
|
|
|
v->s = xstrdup(buf);
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
} else if (!strcmp(formatp, "trackshort") &&
|
2013-12-17 19:47:35 +00:00
|
|
|
starts_with(name, "upstream")) {
|
2013-11-18 17:39:11 +00:00
|
|
|
assert(branch);
|
|
|
|
stat_tracking_info(branch, &num_ours, &num_theirs);
|
|
|
|
if (!num_ours && !num_theirs)
|
|
|
|
v->s = "=";
|
|
|
|
else if (!num_ours)
|
|
|
|
v->s = "<";
|
|
|
|
else if (!num_theirs)
|
|
|
|
v->s = ">";
|
|
|
|
else
|
|
|
|
v->s = "<>";
|
|
|
|
continue;
|
|
|
|
} else
|
2009-04-07 07:06:51 +00:00
|
|
|
die("unknown %.*s format %s",
|
|
|
|
(int)(formatp - name), name, formatp);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!deref)
|
|
|
|
v->s = refname;
|
|
|
|
else {
|
|
|
|
int len = strlen(refname);
|
|
|
|
char *s = xmalloc(len + 4);
|
|
|
|
sprintf(s, "%s^{}", refname);
|
|
|
|
v->s = s;
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-27 19:23:12 +00:00
|
|
|
for (i = 0; i < used_atom_cnt; i++) {
|
|
|
|
struct atom_value *v = &ref->value[i];
|
|
|
|
if (v->s == NULL)
|
|
|
|
goto need_obj;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
|
|
|
need_obj:
|
|
|
|
buf = get_obj(ref->objectname, &obj, &size, &eaten);
|
|
|
|
if (!buf)
|
|
|
|
die("missing object %s for %s",
|
|
|
|
sha1_to_hex(ref->objectname), ref->refname);
|
|
|
|
if (!obj)
|
|
|
|
die("parse_object_buffer failed on %s for %s",
|
|
|
|
sha1_to_hex(ref->objectname), ref->refname);
|
|
|
|
|
2006-09-15 20:30:02 +00:00
|
|
|
grab_values(ref->value, 0, obj, buf, size);
|
|
|
|
if (!eaten)
|
|
|
|
free(buf);
|
|
|
|
|
2010-02-13 19:29:27 +00:00
|
|
|
/*
|
|
|
|
* If there is no atom that wants to know about tagged
|
2006-09-15 20:30:02 +00:00
|
|
|
* object, we are done.
|
|
|
|
*/
|
|
|
|
if (!need_tagged || (obj->type != OBJ_TAG))
|
|
|
|
return;
|
|
|
|
|
2010-02-13 19:29:27 +00:00
|
|
|
/*
|
|
|
|
* If it is a tag object, see if we use a value that derefs
|
2006-09-15 20:30:02 +00:00
|
|
|
* the object, and if we do grab the object it refers to.
|
|
|
|
*/
|
|
|
|
tagged = ((struct tag *)obj)->tagged->sha1;
|
|
|
|
|
2010-02-13 19:29:27 +00:00
|
|
|
/*
|
|
|
|
* NEEDSWORK: This derefs tag only once, which
|
2006-09-15 20:30:02 +00:00
|
|
|
* is good to deal with chains of trust, but
|
|
|
|
* is not consistent with what deref_tag() does
|
|
|
|
* which peels the onion to the core.
|
|
|
|
*/
|
|
|
|
buf = get_obj(tagged, &obj, &size, &eaten);
|
|
|
|
if (!buf)
|
|
|
|
die("missing object %s for %s",
|
|
|
|
sha1_to_hex(tagged), ref->refname);
|
|
|
|
if (!obj)
|
|
|
|
die("parse_object_buffer failed on %s for %s",
|
|
|
|
sha1_to_hex(tagged), ref->refname);
|
|
|
|
grab_values(ref->value, 1, obj, buf, size);
|
|
|
|
if (!eaten)
|
|
|
|
free(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given a ref, return the value for the atom. This lazily gets value
|
|
|
|
* out of the object by calling populate value.
|
|
|
|
*/
|
|
|
|
static void get_value(struct refinfo *ref, int atom, struct atom_value **v)
|
|
|
|
{
|
|
|
|
if (!ref->value) {
|
|
|
|
populate_value(ref);
|
|
|
|
fill_missing_values(ref->value);
|
|
|
|
}
|
|
|
|
*v = &ref->value[atom];
|
|
|
|
}
|
|
|
|
|
2006-09-21 07:29:37 +00:00
|
|
|
struct grab_ref_cbdata {
|
|
|
|
struct refinfo **grab_array;
|
|
|
|
const char **grab_pattern;
|
|
|
|
int grab_cnt;
|
|
|
|
};
|
2006-09-15 20:30:02 +00:00
|
|
|
|
|
|
|
/*
|
2010-02-13 19:29:27 +00:00
|
|
|
* A call-back given to for_each_ref(). Filter refs and keep them for
|
|
|
|
* later object processing.
|
2006-09-15 20:30:02 +00:00
|
|
|
*/
|
2006-09-21 07:29:37 +00:00
|
|
|
static int grab_single_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
|
2006-09-15 20:30:02 +00:00
|
|
|
{
|
2006-09-21 07:29:37 +00:00
|
|
|
struct grab_ref_cbdata *cb = cb_data;
|
2006-09-15 20:30:02 +00:00
|
|
|
struct refinfo *ref;
|
|
|
|
int cnt;
|
|
|
|
|
2006-09-21 07:29:37 +00:00
|
|
|
if (*cb->grab_pattern) {
|
2006-09-15 20:30:02 +00:00
|
|
|
const char **pattern;
|
|
|
|
int namelen = strlen(refname);
|
2006-09-21 07:29:37 +00:00
|
|
|
for (pattern = cb->grab_pattern; *pattern; pattern++) {
|
2006-09-15 20:30:02 +00:00
|
|
|
const char *p = *pattern;
|
|
|
|
int plen = strlen(p);
|
|
|
|
|
|
|
|
if ((plen <= namelen) &&
|
|
|
|
!strncmp(refname, p, plen) &&
|
|
|
|
(refname[plen] == '\0' ||
|
2008-08-28 02:14:02 +00:00
|
|
|
refname[plen] == '/' ||
|
|
|
|
p[plen-1] == '/'))
|
2006-09-15 20:30:02 +00:00
|
|
|
break;
|
|
|
|
if (!fnmatch(p, refname, FNM_PATHNAME))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!*pattern)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-02-13 19:29:27 +00:00
|
|
|
/*
|
|
|
|
* We do not open the object yet; sort may only need refname
|
2006-09-15 20:30:02 +00:00
|
|
|
* to do its job and the resulting list may yet to be pruned
|
|
|
|
* by maxcount logic.
|
|
|
|
*/
|
|
|
|
ref = xcalloc(1, sizeof(*ref));
|
|
|
|
ref->refname = xstrdup(refname);
|
|
|
|
hashcpy(ref->objectname, sha1);
|
2010-02-13 19:57:08 +00:00
|
|
|
ref->flag = flag;
|
2006-09-15 20:30:02 +00:00
|
|
|
|
2006-09-21 07:29:37 +00:00
|
|
|
cnt = cb->grab_cnt;
|
|
|
|
cb->grab_array = xrealloc(cb->grab_array,
|
|
|
|
sizeof(*cb->grab_array) * (cnt + 1));
|
|
|
|
cb->grab_array[cnt++] = ref;
|
|
|
|
cb->grab_cnt = cnt;
|
2006-09-15 20:30:02 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cmp_ref_sort(struct ref_sort *s, struct refinfo *a, struct refinfo *b)
|
|
|
|
{
|
|
|
|
struct atom_value *va, *vb;
|
|
|
|
int cmp;
|
|
|
|
cmp_type cmp_type = used_atom_type[s->atom];
|
|
|
|
|
|
|
|
get_value(a, s->atom, &va);
|
|
|
|
get_value(b, s->atom, &vb);
|
|
|
|
switch (cmp_type) {
|
|
|
|
case FIELD_STR:
|
|
|
|
cmp = strcmp(va->s, vb->s);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (va->ul < vb->ul)
|
|
|
|
cmp = -1;
|
|
|
|
else if (va->ul == vb->ul)
|
|
|
|
cmp = 0;
|
|
|
|
else
|
|
|
|
cmp = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return (s->reverse) ? -cmp : cmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ref_sort *ref_sort;
|
|
|
|
static int compare_refs(const void *a_, const void *b_)
|
|
|
|
{
|
|
|
|
struct refinfo *a = *((struct refinfo **)a_);
|
|
|
|
struct refinfo *b = *((struct refinfo **)b_);
|
|
|
|
struct ref_sort *s;
|
|
|
|
|
|
|
|
for (s = ref_sort; s; s = s->next) {
|
|
|
|
int cmp = cmp_ref_sort(s, a, b);
|
|
|
|
if (cmp)
|
|
|
|
return cmp;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void sort_refs(struct ref_sort *sort, struct refinfo **refs, int num_refs)
|
|
|
|
{
|
|
|
|
ref_sort = sort;
|
|
|
|
qsort(refs, num_refs, sizeof(struct refinfo *), compare_refs);
|
|
|
|
}
|
|
|
|
|
2013-11-18 17:39:13 +00:00
|
|
|
static void print_value(struct atom_value *v, int quote_style)
|
2006-09-15 20:30:02 +00:00
|
|
|
{
|
2013-07-30 08:31:25 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2006-09-15 20:30:02 +00:00
|
|
|
switch (quote_style) {
|
|
|
|
case QUOTE_NONE:
|
|
|
|
fputs(v->s, stdout);
|
|
|
|
break;
|
|
|
|
case QUOTE_SHELL:
|
2013-07-30 08:31:25 +00:00
|
|
|
sq_quote_buf(&sb, v->s);
|
2006-09-15 20:30:02 +00:00
|
|
|
break;
|
|
|
|
case QUOTE_PERL:
|
2013-07-30 08:31:25 +00:00
|
|
|
perl_quote_buf(&sb, v->s);
|
2006-09-15 20:30:02 +00:00
|
|
|
break;
|
|
|
|
case QUOTE_PYTHON:
|
2013-07-30 08:31:25 +00:00
|
|
|
python_quote_buf(&sb, v->s);
|
2006-09-15 20:30:02 +00:00
|
|
|
break;
|
2007-01-28 07:39:13 +00:00
|
|
|
case QUOTE_TCL:
|
2013-07-30 08:31:25 +00:00
|
|
|
tcl_quote_buf(&sb, v->s);
|
2007-01-28 07:39:13 +00:00
|
|
|
break;
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
2013-07-30 08:31:25 +00:00
|
|
|
if (quote_style != QUOTE_NONE) {
|
|
|
|
fputs(sb.buf, stdout);
|
|
|
|
strbuf_release(&sb);
|
|
|
|
}
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hex1(char ch)
|
|
|
|
{
|
|
|
|
if ('0' <= ch && ch <= '9')
|
|
|
|
return ch - '0';
|
|
|
|
else if ('a' <= ch && ch <= 'f')
|
|
|
|
return ch - 'a' + 10;
|
|
|
|
else if ('A' <= ch && ch <= 'F')
|
|
|
|
return ch - 'A' + 10;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
static int hex2(const char *cp)
|
|
|
|
{
|
|
|
|
if (cp[0] && cp[1])
|
|
|
|
return (hex1(cp[0]) << 4) | hex1(cp[1]);
|
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void emit(const char *cp, const char *ep)
|
|
|
|
{
|
|
|
|
while (*cp && (!ep || cp < ep)) {
|
|
|
|
if (*cp == '%') {
|
|
|
|
if (cp[1] == '%')
|
|
|
|
cp++;
|
|
|
|
else {
|
|
|
|
int ch = hex2(cp + 1);
|
|
|
|
if (0 <= ch) {
|
|
|
|
putchar(ch);
|
|
|
|
cp += 3;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
putchar(*cp);
|
|
|
|
cp++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void show_ref(struct refinfo *info, const char *format, int quote_style)
|
|
|
|
{
|
|
|
|
const char *cp, *sp, *ep;
|
|
|
|
|
|
|
|
for (cp = format; *cp && (sp = find_next(cp)); cp = ep + 1) {
|
2013-11-18 17:39:13 +00:00
|
|
|
struct atom_value *atomv;
|
|
|
|
|
2006-09-15 20:30:02 +00:00
|
|
|
ep = strchr(sp, ')');
|
|
|
|
if (cp < sp)
|
|
|
|
emit(cp, sp);
|
2013-11-18 17:39:13 +00:00
|
|
|
get_value(info, parse_atom(sp + 2, ep), &atomv);
|
|
|
|
print_value(atomv, quote_style);
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
|
|
|
if (*cp) {
|
|
|
|
sp = cp + strlen(cp);
|
|
|
|
emit(cp, sp);
|
|
|
|
}
|
2013-11-18 17:39:13 +00:00
|
|
|
if (need_color_reset_at_eol) {
|
|
|
|
struct atom_value resetv;
|
|
|
|
char color[COLOR_MAXLEN] = "";
|
|
|
|
|
|
|
|
color_parse("reset", "--format", color);
|
|
|
|
resetv.s = color;
|
|
|
|
print_value(&resetv, quote_style);
|
|
|
|
}
|
2006-09-15 20:30:02 +00:00
|
|
|
putchar('\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct ref_sort *default_sort(void)
|
|
|
|
{
|
|
|
|
static const char cstr_name[] = "refname";
|
|
|
|
|
|
|
|
struct ref_sort *sort = xcalloc(1, sizeof(*sort));
|
|
|
|
|
|
|
|
sort->next = NULL;
|
|
|
|
sort->atom = parse_atom(cstr_name, cstr_name + strlen(cstr_name));
|
|
|
|
return sort;
|
|
|
|
}
|
|
|
|
|
2008-07-23 23:09:35 +00:00
|
|
|
static int opt_parse_sort(const struct option *opt, const char *arg, int unset)
|
2007-10-13 18:40:46 +00:00
|
|
|
{
|
|
|
|
struct ref_sort **sort_tail = opt->value;
|
|
|
|
struct ref_sort *s;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
if (!arg) /* should --no-sort void the list ? */
|
|
|
|
return -1;
|
|
|
|
|
2012-08-21 07:47:26 +00:00
|
|
|
s = xcalloc(1, sizeof(*s));
|
|
|
|
s->next = *sort_tail;
|
|
|
|
*sort_tail = s;
|
2007-10-13 18:40:46 +00:00
|
|
|
|
|
|
|
if (*arg == '-') {
|
|
|
|
s->reverse = 1;
|
|
|
|
arg++;
|
|
|
|
}
|
|
|
|
len = strlen(arg);
|
|
|
|
s->atom = parse_atom(arg, arg+len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static char const * const for_each_ref_usage[] = {
|
2012-08-20 12:32:11 +00:00
|
|
|
N_("git for-each-ref [options] [<pattern>]"),
|
2007-10-13 18:40:46 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
int cmd_for_each_ref(int argc, const char **argv, const char *prefix)
|
2006-09-15 20:30:02 +00:00
|
|
|
{
|
|
|
|
int i, num_refs;
|
2007-10-13 18:40:46 +00:00
|
|
|
const char *format = "%(objectname) %(objecttype)\t%(refname)";
|
2006-09-15 20:30:02 +00:00
|
|
|
struct ref_sort *sort = NULL, **sort_tail = &sort;
|
2007-11-07 10:20:29 +00:00
|
|
|
int maxcount = 0, quote_style = 0;
|
2006-09-15 20:30:02 +00:00
|
|
|
struct refinfo **refs;
|
2006-09-21 07:29:37 +00:00
|
|
|
struct grab_ref_cbdata cbdata;
|
2006-09-15 20:30:02 +00:00
|
|
|
|
2007-10-13 18:40:46 +00:00
|
|
|
struct option opts[] = {
|
2007-11-07 10:20:29 +00:00
|
|
|
OPT_BIT('s', "shell", "e_style,
|
2012-08-20 12:32:11 +00:00
|
|
|
N_("quote placeholders suitably for shells"), QUOTE_SHELL),
|
2007-11-07 10:20:29 +00:00
|
|
|
OPT_BIT('p', "perl", "e_style,
|
2012-08-20 12:32:11 +00:00
|
|
|
N_("quote placeholders suitably for perl"), QUOTE_PERL),
|
2007-11-07 10:20:29 +00:00
|
|
|
OPT_BIT(0 , "python", "e_style,
|
2012-08-20 12:32:11 +00:00
|
|
|
N_("quote placeholders suitably for python"), QUOTE_PYTHON),
|
2007-11-07 10:20:29 +00:00
|
|
|
OPT_BIT(0 , "tcl", "e_style,
|
2012-08-20 12:32:11 +00:00
|
|
|
N_("quote placeholders suitably for tcl"), QUOTE_TCL),
|
2007-10-13 18:40:46 +00:00
|
|
|
|
|
|
|
OPT_GROUP(""),
|
2012-08-20 12:32:11 +00:00
|
|
|
OPT_INTEGER( 0 , "count", &maxcount, N_("show only <n> matched refs")),
|
|
|
|
OPT_STRING( 0 , "format", &format, N_("format"), N_("format to use for the output")),
|
|
|
|
OPT_CALLBACK(0 , "sort", sort_tail, N_("key"),
|
|
|
|
N_("field name to sort on"), &opt_parse_sort),
|
2007-10-13 18:40:46 +00:00
|
|
|
OPT_END(),
|
|
|
|
};
|
|
|
|
|
2009-05-23 18:53:12 +00:00
|
|
|
parse_options(argc, argv, prefix, opts, for_each_ref_usage, 0);
|
2007-10-13 18:40:46 +00:00
|
|
|
if (maxcount < 0) {
|
|
|
|
error("invalid --count argument: `%d'", maxcount);
|
|
|
|
usage_with_options(for_each_ref_usage, opts);
|
2006-09-15 20:30:02 +00:00
|
|
|
}
|
2007-11-07 10:20:29 +00:00
|
|
|
if (HAS_MULTI_BITS(quote_style)) {
|
2007-12-06 12:24:39 +00:00
|
|
|
error("more than one quoting style?");
|
2007-10-13 18:40:46 +00:00
|
|
|
usage_with_options(for_each_ref_usage, opts);
|
|
|
|
}
|
|
|
|
if (verify_format(format))
|
|
|
|
usage_with_options(for_each_ref_usage, opts);
|
2006-09-15 20:30:02 +00:00
|
|
|
|
|
|
|
if (!sort)
|
|
|
|
sort = default_sort();
|
|
|
|
|
2009-04-13 10:25:47 +00:00
|
|
|
/* for warn_ambiguous_refs */
|
|
|
|
git_config(git_default_config, NULL);
|
|
|
|
|
2006-09-21 07:29:37 +00:00
|
|
|
memset(&cbdata, 0, sizeof(cbdata));
|
2007-10-13 18:40:46 +00:00
|
|
|
cbdata.grab_pattern = argv;
|
2009-05-27 19:23:12 +00:00
|
|
|
for_each_rawref(grab_single_ref, &cbdata);
|
2006-09-21 07:29:37 +00:00
|
|
|
refs = cbdata.grab_array;
|
|
|
|
num_refs = cbdata.grab_cnt;
|
2006-09-15 20:30:02 +00:00
|
|
|
|
|
|
|
sort_refs(sort, refs, num_refs);
|
|
|
|
|
|
|
|
if (!maxcount || num_refs < maxcount)
|
|
|
|
maxcount = num_refs;
|
|
|
|
for (i = 0; i < maxcount; i++)
|
|
|
|
show_ref(refs[i], format, quote_style);
|
|
|
|
return 0;
|
|
|
|
}
|