int main()
{
auto && abc = get("abc");
print_signature(abc);
print_signature(std::common_type<decltype(abc)>{});
auto && def = get("def");
std::cout << std::is_same<decltype(abc), decltype(def)>::value << std::endl;
}
void program_dump(ast_t* program)
{
pony_assert(program != NULL);
pony_assert(ast_id(program) == TK_PROGRAM);
program_t* data = (program_t*)ast_data(program);
pony_assert(data != NULL);
const char* signature = program_signature(program);
fputs("Program signature: ", stdout);
print_signature(signature);
puts("\n");
size_t i = 0;
package_group_list_t* iter = data->package_groups;
while(iter != NULL)
{
printf("Group " __zu "\n", i);
package_group_t* group = package_group_list_data(iter);
package_group_dump(group);
putchar('\n');
iter = package_group_list_next(iter);
i++;
}
}
void test2(){
struct BayesSignature * signature;
char * signature_directory = "/home/liquid/eclipseworkspace/SignatureMatcher";
signature = new_Signature_s(signature_directory, "real_signature1");
print_signature(signature);
destruct_signature(signature);
}
// ------------------------------------------------------------------
// ciSignature::print
void ciSignature::print() {
tty->print("<ciSignature symbol=");
print_signature();
tty->print(" accessing_klass=");
_accessing_klass->print();
tty->print(" address=0x%x>", (address)this);
}
static void test_eq(arena_t *m, occ_t t1, occ_t t2) {
composite_t *tmp;
tmp = arena_eq_composite(m, t1, t2);
signature_composite(tmp, label, &sgn);
print_composite(stdout, tmp);
printf("\t---> signature = ");
print_signature(stdout, &sgn);
printf("\n");
}
/**
* Commits and tags have a few interesting fields in their header.
*/
static void show_commit(const git_commit *commit)
{
unsigned int i, max_i;
char oidstr[GIT_OID_HEXSZ + 1];
git_oid_tostr(oidstr, sizeof(oidstr), git_commit_tree_id(commit));
printf("tree %s\n", oidstr);
max_i = (unsigned int)git_commit_parentcount(commit);
for (i = 0; i < max_i; ++i) {
git_oid_tostr(oidstr, sizeof(oidstr), git_commit_parent_id(commit, i));
printf("parent %s\n", oidstr);
}
print_signature("author", git_commit_author(commit));
print_signature("committer", git_commit_committer(commit));
if (git_commit_message(commit))
printf("\n%s\n", git_commit_message(commit));
}
static void test_congruences(uint32_t n) {
uint32_t k;
composite_t *tmp, *root;
uint32_t nroots;
composite_t *roots[n];
nroots = 0;
for (k=0; k<n; k++) {
print_composite(stdout, composite[k]);
printf("\n");
signature_composite(composite[k], label, &sgn);
printf("---> signature = ");
print_signature(stdout, &sgn);
printf("\n");
root = congruence_table_find(&tbl, &sgn, label);
if (root == NULL) {
printf("---> not in congruence table\n");
} else {
printf("---> congruent to term: ");
print_composite(stdout, root);
printf("\n");
}
tmp = congruence_table_get(&tbl, composite[k], &sgn, label);
printf("---> get returns: ");
print_composite(stdout, tmp);
printf("\n");
if (tmp == composite[k] && root == NULL) {
printf("---> added as congruence root\n");
roots[nroots] = tmp;
nroots ++;
} else if (tmp == root && root != NULL) {
printf("---> confirmed congruence\n");
} else {
printf("\n*** BUG: get/find disagree ***\n");
}
printf("\n");
fflush(stdout);
}
for (k=0; k<nroots; k++) {
tmp = roots[k];
printf("---> removing root: ");
print_composite(stdout, tmp);
printf("\n");
congruence_table_remove(&tbl, tmp);
}
printf("\n");
fflush(stdout);
}
void test3(){
struct BayesSignature * signature;
signature = new_Signature_i(2, "6f0c36d455f86922ae69808d00bcbadd");
struct Token * t1, * t2;
t1 = new_Token("test", 0.7, 4);
t2 = new_Token("tada", 0.6, 4);
add_Token(signature, t1);
add_Token(signature, t2);
add_threshold(signature, 2.04);
print_signature(signature);
}
static void show_tag(const git_tag *tag)
{
char oidstr[GIT_OID_HEXSZ + 1];
git_oid_tostr(oidstr, sizeof(oidstr), git_tag_target_id(tag));;
printf("object %s\n", oidstr);
printf("type %s\n", git_object_type2string(git_tag_target_type(tag)));
printf("tag %s\n", git_tag_name(tag));
print_signature("tagger", git_tag_tagger(tag));
if (git_tag_message(tag))
printf("\n%s\n", git_tag_message(tag));
}
static void test_signatures(uint32_t n) {
uint32_t k;
for (k=0; k<n; k++) {
printf("cmp[%"PRIu32"] = ", k);
print_composite(stdout, composite[k]);
printf("\n");
signature_composite(composite[k], label, &sgn);
printf("---> signature = ");
print_signature(stdout, &sgn);
printf("\n");
}
}
void package_group_dump(package_group_t* group)
{
package_set_t deps;
package_set_init(&deps, 1);
fputs("Signature: ", stdout);
if(group->signature != NULL)
print_signature(group->signature);
else
fputs("(NONE)", stdout);
putchar('\n');
puts("Members:");
size_t i = HASHMAP_BEGIN;
package_t* member;
while((member = package_set_next(&group->members, &i)) != NULL)
{
printf(" %s\n", member->filename);
size_t j = HASHMAP_BEGIN;
package_t* dep;
while((dep = package_set_next(&member->dependencies, &j)) != NULL)
{
size_t k = HASHMAP_UNKNOWN;
package_t* in_set = package_set_get(&group->members, dep, &k);
if(in_set == NULL)
{
k = HASHMAP_UNKNOWN;
in_set = package_set_get(&deps, dep, &k);
if(in_set == NULL)
package_set_putindex(&deps, dep, k);
}
}
}
puts("Dependencies:");
i = HASHMAP_BEGIN;
while((member = package_set_next(&deps, &i)) != NULL)
printf(" %s\n", member->filename);
package_set_destroy(&deps);
}
static void test_or3(arena_t *m, occ_t t1, occ_t t2, occ_t t3) {
occ_t aux[3];
composite_t *tmp;
aux[0] = t1;
aux[1] = t2;
aux[2] = t3;
tmp = arena_or_composite(m, 3, aux);
signature_or(tmp, label, &sgn);
print_composite(stdout, tmp);
printf("\t---> signature = ");
print_signature(stdout, &sgn);
printf("\n");
}
static void make_cover_letter(struct rev_info *rev, int use_stdout,
int numbered, int numbered_files,
struct commit *origin,
int nr, struct commit **list, struct commit *head,
const char *branch_name,
int quiet)
{
const char *committer;
const char *body = "*** SUBJECT HERE ***\n\n*** BLURB HERE ***\n";
const char *msg;
struct shortlog log;
struct strbuf sb = STRBUF_INIT;
int i;
const char *encoding = "UTF-8";
struct diff_options opts;
int need_8bit_cte = 0;
struct pretty_print_context pp = {0};
if (rev->commit_format != CMIT_FMT_EMAIL)
die(_("Cover letter needs email format"));
committer = git_committer_info(0);
if (!use_stdout &&
reopen_stdout(NULL, numbered_files ? NULL : "cover-letter", rev, quiet))
return;
log_write_email_headers(rev, head, &pp.subject, &pp.after_subject,
&need_8bit_cte);
for (i = 0; !need_8bit_cte && i < nr; i++)
if (has_non_ascii(list[i]->buffer))
need_8bit_cte = 1;
msg = body;
pp.fmt = CMIT_FMT_EMAIL;
pp.date_mode = DATE_RFC2822;
pp_user_info(&pp, NULL, &sb, committer, encoding);
pp_title_line(&pp, &msg, &sb, encoding, need_8bit_cte);
pp_remainder(&pp, &msg, &sb, 0);
add_branch_description(&sb, branch_name);
printf("%s\n", sb.buf);
strbuf_release(&sb);
shortlog_init(&log);
log.wrap_lines = 1;
log.wrap = 72;
log.in1 = 2;
log.in2 = 4;
for (i = 0; i < nr; i++)
shortlog_add_commit(&log, list[i]);
shortlog_output(&log);
/*
* We can only do diffstat with a unique reference point
*/
if (!origin)
return;
memcpy(&opts, &rev->diffopt, sizeof(opts));
opts.output_format = DIFF_FORMAT_SUMMARY | DIFF_FORMAT_DIFFSTAT;
diff_setup_done(&opts);
diff_tree_sha1(origin->tree->object.sha1,
head->tree->object.sha1,
"", &opts);
diffcore_std(&opts);
diff_flush(&opts);
printf("\n");
print_signature();
}
int cmd_format_patch(int argc, const char **argv, const char *prefix)
{
struct commit *commit;
struct commit **list = NULL;
struct rev_info rev;
struct setup_revision_opt s_r_opt;
int nr = 0, total, i;
int use_stdout = 0;
int start_number = -1;
int numbered_files = 0; /* _just_ numbers */
int ignore_if_in_upstream = 0;
int cover_letter = 0;
int boundary_count = 0;
int no_binary_diff = 0;
struct commit *origin = NULL, *head = NULL;
const char *in_reply_to = NULL;
struct patch_ids ids;
char *add_signoff = NULL;
struct strbuf buf = STRBUF_INIT;
int use_patch_format = 0;
int quiet = 0;
char *branch_name = NULL;
const struct option builtin_format_patch_options[] = {
{ OPTION_CALLBACK, 'n', "numbered", &numbered, NULL,
N_("use [PATCH n/m] even with a single patch"),
PARSE_OPT_NOARG, numbered_callback },
{ OPTION_CALLBACK, 'N', "no-numbered", &numbered, NULL,
N_("use [PATCH] even with multiple patches"),
PARSE_OPT_NOARG, no_numbered_callback },
OPT_BOOLEAN('s', "signoff", &do_signoff, N_("add Signed-off-by:")),
OPT_BOOLEAN(0, "stdout", &use_stdout,
N_("print patches to standard out")),
OPT_BOOLEAN(0, "cover-letter", &cover_letter,
N_("generate a cover letter")),
OPT_BOOLEAN(0, "numbered-files", &numbered_files,
N_("use simple number sequence for output file names")),
OPT_STRING(0, "suffix", &fmt_patch_suffix, N_("sfx"),
N_("use <sfx> instead of '.patch'")),
OPT_INTEGER(0, "start-number", &start_number,
N_("start numbering patches at <n> instead of 1")),
{ OPTION_CALLBACK, 0, "subject-prefix", &rev, N_("prefix"),
N_("Use [<prefix>] instead of [PATCH]"),
PARSE_OPT_NONEG, subject_prefix_callback },
{ OPTION_CALLBACK, 'o', "output-directory", &output_directory,
N_("dir"), N_("store resulting files in <dir>"),
PARSE_OPT_NONEG, output_directory_callback },
{ OPTION_CALLBACK, 'k', "keep-subject", &rev, NULL,
N_("don't strip/add [PATCH]"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, keep_callback },
OPT_BOOLEAN(0, "no-binary", &no_binary_diff,
N_("don't output binary diffs")),
OPT_BOOLEAN(0, "ignore-if-in-upstream", &ignore_if_in_upstream,
N_("don't include a patch matching a commit upstream")),
{ OPTION_BOOLEAN, 'p', "no-stat", &use_patch_format, NULL,
N_("show patch format instead of default (patch + stat)"),
PARSE_OPT_NONEG | PARSE_OPT_NOARG },
OPT_GROUP(N_("Messaging")),
{ OPTION_CALLBACK, 0, "add-header", NULL, N_("header"),
N_("add email header"), 0, header_callback },
{ OPTION_CALLBACK, 0, "to", NULL, N_("email"), N_("add To: header"),
0, to_callback },
{ OPTION_CALLBACK, 0, "cc", NULL, N_("email"), N_("add Cc: header"),
0, cc_callback },
OPT_STRING(0, "in-reply-to", &in_reply_to, N_("message-id"),
N_("make first mail a reply to <message-id>")),
{ OPTION_CALLBACK, 0, "attach", &rev, N_("boundary"),
N_("attach the patch"), PARSE_OPT_OPTARG,
attach_callback },
{ OPTION_CALLBACK, 0, "inline", &rev, N_("boundary"),
N_("inline the patch"),
PARSE_OPT_OPTARG | PARSE_OPT_NONEG,
inline_callback },
{ OPTION_CALLBACK, 0, "thread", &thread, N_("style"),
N_("enable message threading, styles: shallow, deep"),
PARSE_OPT_OPTARG, thread_callback },
OPT_STRING(0, "signature", &signature, N_("signature"),
N_("add a signature")),
OPT_BOOLEAN(0, "quiet", &quiet,
N_("don't print the patch filenames")),
OPT_END()
};
extra_hdr.strdup_strings = 1;
extra_to.strdup_strings = 1;
extra_cc.strdup_strings = 1;
git_config(git_format_config, NULL);
init_revisions(&rev, prefix);
rev.commit_format = CMIT_FMT_EMAIL;
rev.verbose_header = 1;
rev.diff = 1;
rev.max_parents = 1;
DIFF_OPT_SET(&rev.diffopt, RECURSIVE);
rev.subject_prefix = fmt_patch_subject_prefix;
memset(&s_r_opt, 0, sizeof(s_r_opt));
s_r_opt.def = "HEAD";
s_r_opt.revarg_opt = REVARG_COMMITTISH;
if (default_attach) {
rev.mime_boundary = default_attach;
rev.no_inline = 1;
}
/*
* Parse the arguments before setup_revisions(), or something
* like "git format-patch -o a123 HEAD^.." may fail; a123 is
* possibly a valid SHA1.
*/
argc = parse_options(argc, argv, prefix, builtin_format_patch_options,
builtin_format_patch_usage,
PARSE_OPT_KEEP_ARGV0 | PARSE_OPT_KEEP_UNKNOWN |
PARSE_OPT_KEEP_DASHDASH);
if (do_signoff) {
const char *committer;
const char *endpos;
committer = git_committer_info(IDENT_STRICT);
endpos = strchr(committer, '>');
if (!endpos)
die(_("bogus committer info %s"), committer);
add_signoff = xmemdupz(committer, endpos - committer + 1);
}
for (i = 0; i < extra_hdr.nr; i++) {
strbuf_addstr(&buf, extra_hdr.items[i].string);
strbuf_addch(&buf, '\n');
}
if (extra_to.nr)
strbuf_addstr(&buf, "To: ");
for (i = 0; i < extra_to.nr; i++) {
if (i)
strbuf_addstr(&buf, " ");
strbuf_addstr(&buf, extra_to.items[i].string);
if (i + 1 < extra_to.nr)
strbuf_addch(&buf, ',');
strbuf_addch(&buf, '\n');
}
if (extra_cc.nr)
strbuf_addstr(&buf, "Cc: ");
for (i = 0; i < extra_cc.nr; i++) {
if (i)
strbuf_addstr(&buf, " ");
strbuf_addstr(&buf, extra_cc.items[i].string);
if (i + 1 < extra_cc.nr)
strbuf_addch(&buf, ',');
strbuf_addch(&buf, '\n');
}
rev.extra_headers = strbuf_detach(&buf, NULL);
if (start_number < 0)
start_number = 1;
/*
* If numbered is set solely due to format.numbered in config,
* and it would conflict with --keep-subject (-k) from the
* command line, reset "numbered".
*/
if (numbered && keep_subject && !numbered_cmdline_opt)
numbered = 0;
if (numbered && keep_subject)
die (_("-n and -k are mutually exclusive."));
if (keep_subject && subject_prefix)
die (_("--subject-prefix and -k are mutually exclusive."));
rev.preserve_subject = keep_subject;
argc = setup_revisions(argc, argv, &rev, &s_r_opt);
if (argc > 1)
die (_("unrecognized argument: %s"), argv[1]);
if (rev.diffopt.output_format & DIFF_FORMAT_NAME)
die(_("--name-only does not make sense"));
if (rev.diffopt.output_format & DIFF_FORMAT_NAME_STATUS)
die(_("--name-status does not make sense"));
if (rev.diffopt.output_format & DIFF_FORMAT_CHECKDIFF)
die(_("--check does not make sense"));
if (!use_patch_format &&
(!rev.diffopt.output_format ||
rev.diffopt.output_format == DIFF_FORMAT_PATCH))
rev.diffopt.output_format = DIFF_FORMAT_DIFFSTAT | DIFF_FORMAT_SUMMARY;
/* Always generate a patch */
rev.diffopt.output_format |= DIFF_FORMAT_PATCH;
if (!DIFF_OPT_TST(&rev.diffopt, TEXT) && !no_binary_diff)
DIFF_OPT_SET(&rev.diffopt, BINARY);
if (rev.show_notes)
init_display_notes(&rev.notes_opt);
if (!use_stdout)
output_directory = set_outdir(prefix, output_directory);
else
setup_pager();
if (output_directory) {
if (use_stdout)
die(_("standard output, or directory, which one?"));
if (mkdir(output_directory, 0777) < 0 && errno != EEXIST)
die_errno(_("Could not create directory '%s'"),
output_directory);
}
if (rev.pending.nr == 1) {
if (rev.max_count < 0 && !rev.show_root_diff) {
/*
* This is traditional behaviour of "git format-patch
* origin" that prepares what the origin side still
* does not have.
*/
unsigned char sha1[20];
const char *ref;
rev.pending.objects[0].item->flags |= UNINTERESTING;
add_head_to_pending(&rev);
ref = resolve_ref_unsafe("HEAD", sha1, 1, NULL);
if (ref && !prefixcmp(ref, "refs/heads/"))
branch_name = xstrdup(ref + strlen("refs/heads/"));
else
branch_name = xstrdup(""); /* no branch */
}
/*
* Otherwise, it is "format-patch -22 HEAD", and/or
* "format-patch --root HEAD". The user wants
* get_revision() to do the usual traversal.
*/
}
/*
* We cannot move this anywhere earlier because we do want to
* know if --root was given explicitly from the command line.
*/
rev.show_root_diff = 1;
if (cover_letter) {
/*
* NEEDSWORK:randomly pick one positive commit to show
* diffstat; this is often the tip and the command
* happens to do the right thing in most cases, but a
* complex command like "--cover-letter a b c ^bottom"
* picks "c" and shows diffstat between bottom..c
* which may not match what the series represents at
* all and totally broken.
*/
int i;
for (i = 0; i < rev.pending.nr; i++) {
struct object *o = rev.pending.objects[i].item;
if (!(o->flags & UNINTERESTING))
head = (struct commit *)o;
}
/* There is nothing to show; it is not an error, though. */
if (!head)
return 0;
if (!branch_name)
branch_name = find_branch_name(&rev);
}
if (ignore_if_in_upstream) {
/* Don't say anything if head and upstream are the same. */
if (rev.pending.nr == 2) {
struct object_array_entry *o = rev.pending.objects;
if (hashcmp(o[0].item->sha1, o[1].item->sha1) == 0)
return 0;
}
get_patch_ids(&rev, &ids);
}
if (!use_stdout)
realstdout = xfdopen(xdup(1), "w");
if (prepare_revision_walk(&rev))
die(_("revision walk setup failed"));
rev.boundary = 1;
while ((commit = get_revision(&rev)) != NULL) {
if (commit->object.flags & BOUNDARY) {
boundary_count++;
origin = (boundary_count == 1) ? commit : NULL;
continue;
}
if (ignore_if_in_upstream &&
has_commit_patch_id(commit, &ids))
continue;
nr++;
list = xrealloc(list, nr * sizeof(list[0]));
list[nr - 1] = commit;
}
total = nr;
if (!keep_subject && auto_number && total > 1)
numbered = 1;
if (numbered)
rev.total = total + start_number - 1;
if (in_reply_to || thread || cover_letter)
rev.ref_message_ids = xcalloc(1, sizeof(struct string_list));
if (in_reply_to) {
const char *msgid = clean_message_id(in_reply_to);
string_list_append(rev.ref_message_ids, msgid);
}
rev.numbered_files = numbered_files;
rev.patch_suffix = fmt_patch_suffix;
if (cover_letter) {
if (thread)
gen_message_id(&rev, "cover");
make_cover_letter(&rev, use_stdout, numbered, numbered_files,
origin, nr, list, head, branch_name, quiet);
total++;
start_number--;
}
rev.add_signoff = add_signoff;
while (0 <= --nr) {
int shown;
commit = list[nr];
rev.nr = total - nr + (start_number - 1);
/* Make the second and subsequent mails replies to the first */
if (thread) {
/* Have we already had a message ID? */
if (rev.message_id) {
/*
* For deep threading: make every mail
* a reply to the previous one, no
* matter what other options are set.
*
* For shallow threading:
*
* Without --cover-letter and
* --in-reply-to, make every mail a
* reply to the one before.
*
* With --in-reply-to but no
* --cover-letter, make every mail a
* reply to the <reply-to>.
*
* With --cover-letter, make every
* mail but the cover letter a reply
* to the cover letter. The cover
* letter is a reply to the
* --in-reply-to, if specified.
*/
if (thread == THREAD_SHALLOW
&& rev.ref_message_ids->nr > 0
&& (!cover_letter || rev.nr > 1))
free(rev.message_id);
else
string_list_append(rev.ref_message_ids,
rev.message_id);
}
gen_message_id(&rev, sha1_to_hex(commit->object.sha1));
}
if (!use_stdout &&
reopen_stdout(numbered_files ? NULL : commit, NULL, &rev, quiet))
die(_("Failed to create output files"));
shown = log_tree_commit(&rev, commit);
free(commit->buffer);
commit->buffer = NULL;
/* We put one extra blank line between formatted
* patches and this flag is used by log-tree code
* to see if it needs to emit a LF before showing
* the log; when using one file per patch, we do
* not want the extra blank line.
*/
if (!use_stdout)
rev.shown_one = 0;
if (shown) {
if (rev.mime_boundary)
printf("\n--%s%s--\n\n\n",
mime_boundary_leader,
rev.mime_boundary);
else
print_signature();
}
if (!use_stdout)
fclose(stdout);
}
free(list);
free(branch_name);
string_list_clear(&extra_to, 0);
string_list_clear(&extra_cc, 0);
string_list_clear(&extra_hdr, 0);
if (ignore_if_in_upstream)
free_patch_ids(&ids);
return 0;
}
static void make_cover_letter(struct rev_info *rev, int use_stdout,
int numbered, int numbered_files,
struct commit *origin,
int nr, struct commit **list, struct commit *head)
{
const char *committer;
const char *subject_start = NULL;
const char *body = "*** SUBJECT HERE ***\n\n*** BLURB HERE ***\n";
const char *msg;
const char *extra_headers = rev->extra_headers;
struct shortlog log;
struct strbuf sb = STRBUF_INIT;
int i;
const char *encoding = "UTF-8";
struct diff_options opts;
int need_8bit_cte = 0;
struct commit *commit = NULL;
if (rev->commit_format != CMIT_FMT_EMAIL)
die("Cover letter needs email format");
committer = git_committer_info(0);
if (!numbered_files) {
/*
* We fake a commit for the cover letter so we get the filename
* desired.
*/
commit = xcalloc(1, sizeof(*commit));
commit->buffer = xmalloc(400);
snprintf(commit->buffer, 400,
"tree 0000000000000000000000000000000000000000\n"
"parent %s\n"
"author %s\n"
"committer %s\n\n"
"cover letter\n",
sha1_to_hex(head->object.sha1), committer, committer);
}
if (!use_stdout && reopen_stdout(commit, rev))
return;
if (commit) {
free(commit->buffer);
free(commit);
}
log_write_email_headers(rev, head, &subject_start, &extra_headers,
&need_8bit_cte);
for (i = 0; !need_8bit_cte && i < nr; i++)
if (has_non_ascii(list[i]->buffer))
need_8bit_cte = 1;
msg = body;
pp_user_info(NULL, CMIT_FMT_EMAIL, &sb, committer, DATE_RFC2822,
encoding);
pp_title_line(CMIT_FMT_EMAIL, &msg, &sb, subject_start, extra_headers,
encoding, need_8bit_cte);
pp_remainder(CMIT_FMT_EMAIL, &msg, &sb, 0);
printf("%s\n", sb.buf);
strbuf_release(&sb);
shortlog_init(&log);
log.wrap_lines = 1;
log.wrap = 72;
log.in1 = 2;
log.in2 = 4;
for (i = 0; i < nr; i++)
shortlog_add_commit(&log, list[i]);
shortlog_output(&log);
/*
* We can only do diffstat with a unique reference point
*/
if (!origin)
return;
memcpy(&opts, &rev->diffopt, sizeof(opts));
opts.output_format = DIFF_FORMAT_SUMMARY | DIFF_FORMAT_DIFFSTAT;
diff_setup_done(&opts);
diff_tree_sha1(origin->tree->object.sha1,
head->tree->object.sha1,
"", &opts);
diffcore_std(&opts);
diff_flush(&opts);
printf("\n");
print_signature();
}
static void
print_constant (FILE *out, JCF *jcf, int index, int verbosity)
{
int j, n;
jlong num;
const char *str;
int kind = JPOOL_TAG (jcf, index);
switch (kind)
{
case CONSTANT_Class:
n = JPOOL_USHORT1 (jcf, index);
if (verbosity > 0)
{
if (verbosity > 1)
fprintf (out, "Class name: %d=", n);
else
fprintf (out, "Class ");
}
if (! CPOOL_INDEX_IN_RANGE (&jcf->cpool, n))
fprintf (out, "<out of range>");
else if (verbosity < 2 && JPOOL_TAG (jcf, n) == CONSTANT_Utf8)
{
int len = JPOOL_UTF_LENGTH (jcf, n);
jcf_print_utf8_replace (out, JPOOL_UTF_DATA(jcf,n), len, '/', '.');
}
else
print_constant_terse (out, jcf, n, CONSTANT_Utf8);
break;
case CONSTANT_Fieldref:
str = "Field"; goto field_or_method;
case CONSTANT_Methodref:
str = "Method"; goto field_or_method;
case CONSTANT_InterfaceMethodref:
str = "InterfaceMethod"; goto field_or_method;
field_or_method:
{
uint16 tclass = JPOOL_USHORT1 (jcf, index);
uint16 name_and_type = JPOOL_USHORT2 (jcf, index);
if (verbosity == 2)
fprintf (out, "%sref class: %d=", str, tclass);
else if (verbosity > 0)
fprintf (out, "%s ", str);
print_constant_terse (out, jcf, tclass, CONSTANT_Class);
if (verbosity < 2)
fprintf (out, ".");
else
fprintf (out, " name_and_type: %d=<", name_and_type);
print_constant_terse (out, jcf, name_and_type, CONSTANT_NameAndType);
if (verbosity == 2)
fputc ('>', out);
}
break;
case CONSTANT_String:
j = JPOOL_USHORT1 (jcf, index);
if (verbosity > 0)
{
if (verbosity > 1)
fprintf (out, "String %d=", j);
else
fprintf (out, "String ");
}
print_constant_terse (out, jcf, j, CONSTANT_Utf8);
break;
case CONSTANT_Integer:
if (verbosity > 0)
fprintf (out, "Integer ");
num = JPOOL_INT (jcf, index);
goto integer;
case CONSTANT_Long:
if (verbosity > 0)
fprintf (out, "Long ");
num = JPOOL_LONG (jcf, index);
goto integer;
integer:
{
char buffer[25];
format_int (buffer, num, 10);
fprintf (out, "%s", buffer);
if (verbosity > 1)
{
format_uint (buffer, (uint64)num, 16);
fprintf (out, "=0x%s", buffer);
}
}
break;
case CONSTANT_Float:
{
jfloat fnum = JPOOL_FLOAT (jcf, index);
if (verbosity > 0)
fputs ("Float ", out);
if (fnum.negative)
putc ('-', out);
if (JFLOAT_FINITE (fnum))
{
int dummy;
int exponent = fnum.exponent - JFLOAT_EXP_BIAS;
double f;
uint32 mantissa = fnum.mantissa;
if (fnum.exponent == 0)
/* Denormal. */
exponent++;
else
/* Normal; add the implicit bit. */
mantissa |= ((uint32)1 << 23);
f = frexp (mantissa, &dummy);
f = ldexp (f, exponent + 1);
fprintf (out, "%.10g", f);
}
else
{
if (fnum.mantissa == 0)
fputs ("Inf", out);
else if (fnum.mantissa & JFLOAT_QNAN_MASK)
fprintf (out, "QNaN(%u)", (fnum.mantissa & ~JFLOAT_QNAN_MASK));
else
fprintf (out, "SNaN(%u)", (fnum.mantissa & ~JFLOAT_QNAN_MASK));
}
if (verbosity > 1)
fprintf (out, ", bits = 0x%08lx", (long) JPOOL_UINT (jcf, index));
break;
}
case CONSTANT_Double:
{
jdouble dnum = JPOOL_DOUBLE (jcf, index);
if (verbosity > 0)
fputs ("Double ", out);
if (dnum.negative)
putc ('-', out);
if (JDOUBLE_FINITE (dnum))
{
int dummy;
int exponent = dnum.exponent - JDOUBLE_EXP_BIAS;
double d;
uint64 mantissa = ((((uint64) dnum.mantissa0) << 32)
+ dnum.mantissa1);
if (dnum.exponent == 0)
/* Denormal. */
exponent++;
else
/* Normal; add the implicit bit. */
mantissa |= ((uint64)1 << 52);
d = frexp (mantissa, &dummy);
d = ldexp (d, exponent + 1);
fprintf (out, "%.20g", d);
}
else
{
uint64 mantissa = dnum.mantissa0 & ~JDOUBLE_QNAN_MASK;
mantissa = (mantissa << 32) + dnum.mantissa1;
if (dnum.mantissa0 == 0 && dnum.mantissa1 == 0)
fputs ("Inf", out);
else if (dnum.mantissa0 & JDOUBLE_QNAN_MASK)
fprintf (out, "QNaN(%llu)", (unsigned long long)mantissa);
else
fprintf (out, "SNaN(%llu)", (unsigned long long)mantissa);
}
if (verbosity > 1)
{
int32 hi, lo;
hi = JPOOL_UINT (jcf, index);
lo = JPOOL_UINT (jcf, index + 1);
fprintf (out, ", bits = 0x%08lx%08lx", (long) hi, (long) lo);
}
break;
}
case CONSTANT_NameAndType:
{
uint16 name = JPOOL_USHORT1 (jcf, index);
uint16 sig = JPOOL_USHORT2 (jcf, index);
if (verbosity > 0)
{
if (verbosity > 1)
fprintf (out, "NameAndType name: %d=", name);
else
fprintf (out, "NameAndType ");
}
print_name (out, jcf, name);
if (verbosity <= 1)
fputc (' ', out);
else
fprintf (out, ", signature: %d=", sig);
print_signature (out, jcf, sig, 0);
}
break;
case CONSTANT_Utf8:
{
const unsigned char *str = JPOOL_UTF_DATA (jcf, index);
int length = JPOOL_UTF_LENGTH (jcf, index);
if (verbosity > 0)
{ /* Print as 8-bit bytes. */
fputs ("Utf8: \"", out);
while (--length >= 0)
jcf_print_char (out, *str++);
}
else
{ /* Print as Unicode. */
fputc ('\"', out);
jcf_print_utf8 (out, str, length);
}
fputc ('\"', out);
}
break;
default:
fprintf (out, "(Unknown constant type %d)", kind);
}
}
int main()
{
auto && abc = get("abc");
print_signature(abc);
print_signature(std::common_type<decltype(abc)>{});
}
