/* cmd-abrowse.c
*
****************************************************************
* Copyright (C) 2003 Tom Lord
*
* See the file "COPYING" for further information about
* the copyright and warranty status of this work.
*/
#include "config-options.h"
#include "po/gettext.h"
#include "hackerlab/bugs/exception.h"
#include "hackerlab/cmd/main.h"
#include "libarch/patch-logs.h"
#include "libarch/namespace.h"
#include "libarch/project-tree.h"
#include "libarch/my.h"
#include "libarch/archive.h"
#include "commands/abrowse.h"
#include "commands/version.h"
static t_uchar * usage = N_("[options] [limit]");
#define OPTS(OP) \
OP (opt_help_msg, "h", "help", 0, \
N_("Display a help message and exit.")) \
OP (opt_long_help, "H", 0, 0, \
N_("Display a verbose help message and exit.")) \
OP (opt_version, "V", "version", 0, \
N_("Display a release identifier string\n" \
"and exit.")) \
OP (opt_reverse, "r", "reverse", 0, \
N_("sort revisions from newest to oldest")) \
OP (opt_summary, "s", "summary", 0, \
N_("print a summary of each patch")) \
OP (opt_creator, "c", "creator", 0, \
N_("print the creator of each patch")) \
OP (opt_date, "D", "date", 0, \
N_("print the date of each patch")) \
OP (opt_kind, "k", "kind", 0, \
N_("show each revision kind (import, changeset or id)")) \
OP (opt_cacherevs, "C", "cacherevs", 0, \
N_("show cached revisions")) \
OP (opt_full, "f", "full", 0, \
N_("print full patch level names")) \
OP (opt_desc, 0, "desc", 0, \
N_("implies -s -c -D -k -C")) \
OP (opt_local_merges, 0, "local-merges", 0, \
N_("list merges from the same archive")) \
OP (opt_foreign_merges, 0, "foreign-merges", 0, \
N_("list merges from other archives")) \
OP (opt_all_merges, 0, "merges", 0, \
N_("list all merges")) \
OP (opt_categories, 0, "categories", 0, \
N_("show category names only")) \
OP (opt_branches, 0, "branches", 0, \
N_("show branch names only")) \
OP (opt_versions, 0, "versions", 0, \
N_("show version names only")) \
OP (opt_omit_empty, 0, "omit-empty", 0, \
N_("omit empty or unchanged-since items")) \
OP (opt_since, 0, "since SNAP-FILE", 1, \
N_("show revisions after those listed in SNAP-FILE")) \
OP (opt_since_limits, 0, "since-limits", 0, \
N_("limit output to items in the since file")) \
OP (opt_snap, 0, "snap SNAP-FILE", 1, \
N_("record the highest revisions shown")) \
OP (opt_force, 0, "force", 0, \
N_("overwrite an existing snap-file"))
t_uchar arch_cmd_abrowse_help[] = N_("print an outline describing archive contents\n"
"Describe the contents of an archive in outline format.\n"
"\n"
"With LIMIT, look only that part of the archive.\n"
"\n"
"LIMIT may be a fully qualified name and may be an archive name.\n");
enum options
{
OPTS (OPT_ENUM)
};
static struct opt_desc opts[] =
{
OPTS (OPT_DESC)
{-1, 0, 0, 0, 0}
};
enum abrowse_depth
{
category_depth,
branch_depth,
version_depth,
revision_depth,
};
int
arch_cmd_abrowse (t_uchar * program_name, int argc, char * argv[])
{
int o;
struct opt_parsed * option;
int reverse = 0;
int wanted_headers = 0;
int show_kind = 0;
int show_cacherevs = 0;
enum abrowse_depth depth = revision_depth;
t_uchar * since = 0;
int since_limits_opt = 0;
t_uchar * snap = 0;
int snap_force = 0;
int omit_empty = 0;
int full = 0;
safe_buffer_fd (1, 0, O_WRONLY, 0);
option = 0;
while (1)
{
o = opt_standard (lim_use_must_malloc, &option, opts, &argc, argv, program_name, usage, libarch_version_string, arch_cmd_abrowse_help, opt_help_msg, opt_long_help, opt_version);
if (o == opt_none)
break;
switch (o)
{
default:
safe_printfmt (2, "unhandled option `%s'\n", option->opt_string);
panic ("internal error parsing arguments");
usage_error:
opt_usage (2, argv[0], program_name, usage, 1);
exit (1);
/* bogus_arg: */
safe_printfmt (2, "ill-formed argument for `%s' (`%s')\n", option->opt_string, option->arg_string);
goto usage_error;
case opt_reverse:
{
reverse = 1;
break;
}
case opt_summary:
{
wanted_headers |= arch_include_summary;
break;
}
case opt_creator:
{
wanted_headers |= arch_include_creator;
break;
}
case opt_date:
{
wanted_headers |= arch_include_date;
break;
}
case opt_local_merges:
{
wanted_headers |= arch_include_local_merges;
break;
}
case opt_foreign_merges:
{
wanted_headers |= arch_include_foreign_merges;
break;
}
case opt_all_merges:
{
wanted_headers |= arch_include_local_merges;
wanted_headers |= arch_include_foreign_merges;
break;
}
case opt_kind:
{
show_kind = 1;
break;
}
case opt_cacherevs:
{
show_cacherevs = 1;
break;
}
case opt_desc:
{
wanted_headers |= (arch_include_summary | arch_include_creator | arch_include_date);
show_kind = 1;
show_cacherevs = 1;
break;
}
case opt_categories:
{
depth = category_depth;
break;
}
case opt_branches:
{
depth = branch_depth;
break;
}
case opt_versions:
{
depth = version_depth;
break;
}
case opt_since:
{
lim_free (0, since);
since = str_save (0, option->arg_string);
break;
}
case opt_since_limits:
{
since_limits_opt = 1;
break;
}
case opt_snap:
{
lim_free (0, since);
snap = str_save (0, option->arg_string);
break;
}
case opt_force:
{
snap_force = 1;
break;
}
case opt_omit_empty:
{
omit_empty = 1;
break;
}
case opt_full:
{
full = 1;
break;
}
}
}
if (argc > 2)
goto usage_error;
{
t_uchar * limit_spec = 0;
t_uchar * limit_category = 0;
t_uchar * limit_branch = 0;
t_uchar * limit_version = 0;
t_uchar * limit_revision = 0;
assoc_table limit_categories = 0;
assoc_table limit_branches = 0;
assoc_table limit_versions = 0;
struct arch_archive * arch = 0;
assoc_table since_limits = 0;
rel_table old_since_limits = 0; /* [0] version [1] level */
rel_table new_since_limits = 0; /* [0] version [1] level */
/********************************
* Set archive and limit spec.
*
*/
if (argc == 2)
{
limit_spec = str_save (0, argv[1]);
}
if (!limit_spec)
limit_spec = arch_my_default_archive (NULL);
if (!limit_spec)
{
arch_project_tree_t * tree = arch_project_tree_new (talloc_context, ".");
if (tree->archive)
limit_spec = str_save (0, tree->archive);
arch_project_tree_delete (tree);
}
if (!str_length (limit_spec))
goto usage_error;
{
/* TODO RBC 20050328 check the project tree */
t_uchar * temp_spec = NULL;
arch = arch_archive_connect_branch (limit_spec, &temp_spec);
if (!arch)
{
safe_printfmt (2, "Could not connect to archive for browsing '%s'\n", limit_spec);
exit (2);
}
lim_free (0, limit_spec);
if (arch_valid_package_name (temp_spec, arch_req_archive, arch_req_category, 1))
limit_spec = arch_parse_package_name (arch_ret_non_archive, NULL, temp_spec);
else
limit_spec = NULL;
lim_free (0, temp_spec);
}
/********************************
* sanity check
*/
if (snap && !snap_force && !safe_access (snap, F_OK))
{
safe_printfmt (2, "%s: --snap output exists and --force not provided (%s)\n",
argv[0], snap);
exit (1);
}
if (snap && (depth != revision_depth))
{
safe_printfmt (2, "%s: --snap is incompatible with --categories, --branches, and --versions\n",
argv[0]);
exit (1);
}
if (since_limits_opt && !since)
{
safe_printfmt (2, "%s: --since-limits requires --since\n", argv[0]);
exit (1);
}
/********************************
* parse the limit spec
*/
if (arch_valid_package_name (limit_spec, arch_maybe_archive, arch_req_category, 1))
{
limit_category = arch_parse_package_name (arch_ret_category, 0, limit_spec);
limit_branch = arch_parse_package_name (arch_ret_package, 0, limit_spec);
if (!str_cmp (limit_category, limit_branch))
{
lim_free (0, limit_branch);
limit_branch = 0;
}
else if (arch_valid_package_name (limit_spec, arch_maybe_archive, arch_req_version, 1))
{
limit_version = arch_parse_package_name (arch_ret_package_version, 0, limit_spec);
if (arch_valid_package_name (limit_spec, arch_maybe_archive, arch_req_patch_level, 0))
limit_revision = arch_parse_package_name (arch_ret_non_archive, 0, limit_spec);
}
}
/********************************
* parse the --since file, if any
*/
if (since)
{
int in_fd;
rel_table since_table = 0;
int s;
in_fd = safe_open (since, O_RDONLY, 0);
since_table = rel_read_table (in_fd, 1, argv[0], since);
for (s = 0; s < rel_n_records (since_table); ++s)
{
t_uchar * rev = 0;
t_uchar * version = 0;
t_uchar * level = 0;
rev = str_save (0, since_table[s][0]);
if (!arch_valid_package_name (rev, arch_no_archive, arch_req_version, 1))
{
safe_printfmt (2, "illegal line in --since file (%s)\n %s\n", since, rev);
exit (1);
}
version = arch_parse_package_name (arch_ret_package_version, 0, rev);
if (arch_valid_package_name (rev, arch_no_archive, arch_req_patch_level, 0))
{
level = arch_parse_package_name (arch_ret_patch_level, 0, rev);
assoc_set (&since_limits, version, level);
rel_add_records (&old_since_limits, rel_make_record (version, level, 0), 0);
}
if (since_limits_opt)
{
t_uchar * category = 0;
t_uchar * branch = 0;
category = arch_parse_package_name (arch_ret_category, 0, rev);
branch = arch_parse_package_name (arch_ret_package, 0, rev);
assoc_set (&limit_categories, category, "yes");
assoc_set (&limit_branches, branch, "yes");
assoc_set (&limit_versions, version, "yes");
lim_free (0, category);
lim_free (0, branch);
}
lim_free (0, rev);
lim_free (0, version);
lim_free (0, level);
}
safe_close (in_fd);
rel_free_table (since_table);
}
/****************************************************************
* produce output
*/
safe_printfmt (1, "%s\n", arch->official_name);
safe_flush (1);
{
rel_table categories = 0;
int c;
t_uchar * last_category_printed = 0;
t_uchar * last_branch_printed = 0;
t_uchar * last_version_printed = 0;
categories = arch_archive_categories (arch);
for (c = 0; c < rel_n_records (categories); ++c)
{
if (limit_category && str_cmp (limit_category, categories[c][0]))
continue;
if (since_limits_opt && !assoc_ref (limit_categories, categories[c][0]))
continue;
if (!omit_empty)
{
safe_printfmt (1, " %s\n", categories[c][0]);
safe_flush (1);
lim_free (0, last_category_printed);
last_category_printed = str_save (0, categories[c][0]);
}
if (omit_empty || (depth != category_depth))
{
rel_table branches = 0;
int b;
branches = arch_archive_branches (arch, categories[c][0]);
for (b = 0; b < rel_n_records (branches); ++b)
{
if (limit_branch && str_cmp (limit_branch, branches[b][0]))
continue;
if (since_limits_opt && !assoc_ref (limit_branches, branches[b][0]))
continue;
if (!omit_empty)
{
safe_printfmt (1, " %s\n", branches[b][0]);
safe_flush (1);
lim_free (0, last_branch_printed);
last_branch_printed = str_save (0, branches[b][0]);
}
if (omit_empty || (depth != branch_depth))
{
rel_table versions = 0;
int v;
versions = arch_archive_versions (arch, branches[b][0]);
for (v = 0; v < rel_n_records (versions); ++v)
{
if (limit_version && str_cmp (limit_version, versions[v][0]))
continue;
if (since_limits_opt && !assoc_ref (limit_versions, versions[v][0]))
continue;
if (!omit_empty)
{
safe_printfmt (1, " %s\n", versions[v][0]);
safe_flush (1);
lim_free (0, last_version_printed);
last_version_printed = str_save (0, versions[v][0]);
}
if (omit_empty || (depth != version_depth))
{
t_uchar * start_at_level = 0;
rel_table revisions = 0;
int r;
int any_output = 0;
{
t_uchar * since_limit = 0;
since_limit = assoc_ref (since_limits, versions[v][0]);
if (since_limit)
start_at_level = str_save (0, since_limit);
}
revisions = arch_archive_revisions (arch, versions[v][0], 0);
if (reverse)
{
arch_sort_table_by_patch_level_field (1, revisions, 0);
if (revisions)
rel_add_records (&new_since_limits, rel_make_record (versions[v][0], revisions[0][0], 0), 0);
}
else
{
if (revisions)
rel_add_records (&new_since_limits, rel_make_record (versions[v][0], revisions[rel_n_records (revisions) - 1][0], 0), 0);
}
for (r = 0; r < rel_n_records (revisions); ++r)
{
if (start_at_level)
{
if (reverse && (0 <= arch_patch_lvl_cmp (start_at_level, revisions[r][0])))
break;
if (!reverse && (0 <= arch_patch_lvl_cmp (start_at_level, revisions[r][0])))
continue;
}
if (!any_output)
{
any_output = 1;
if (omit_empty)
{
if (str_cmp (last_category_printed, categories[c][0]))
{
safe_printfmt (1, " %s\n", categories[c][0]);
lim_free (0, last_category_printed);
last_category_printed = str_save (0, categories[c][0]);
}
if (str_cmp (last_branch_printed, branches[b][0]))
{
safe_printfmt (1, " %s\n", branches[b][0]);
lim_free (0, last_branch_printed);
last_branch_printed = str_save (0, branches[b][0]);
}
if (str_cmp (last_version_printed, versions[v][0]))
{
safe_printfmt (1, " %s\n", versions[v][0]);
lim_free (0, last_version_printed);
last_version_printed = str_save (0, versions[v][0]);
}
}
if (wanted_headers)
safe_printfmt (1, "\n");
}
if (!wanted_headers)
{
if (!show_kind && !show_cacherevs)
{
if (rel_n_records (revisions) == 1)
{
safe_printfmt (1, " %s\n", revisions[r][0]);
}
else
{
int s;
s = rel_n_records (revisions) - 1;
safe_printfmt (1, " %s .. %s\n", revisions[r][0], revisions[s][0]);
r = s;
}
}
else
{
/* show revision kinds and/or cacherevs */
t_uchar * version_stem = 0;
t_uchar * package_revision = 0;
enum arch_revision_type this_type;
int is_cached;
int has_ancestry;
int s;
arch_patch_id * pkg_revision_patch;
version_stem = str_alloc_cat (0, versions[v][0], "--");
package_revision = str_alloc_cat (0, version_stem, revisions[r][0]);
pkg_revision_patch = arch_patch_id_new_archive (arch->official_name, package_revision);
arch_revision_type (&this_type, &is_cached, &has_ancestry, arch, pkg_revision_patch);
if (this_type == arch_continuation_revision)
{
arch_patch_id * tagged = arch_get_continuation (arch, pkg_revision_patch);
safe_printfmt (1, " %s", revisions[r][0]);
if (show_kind)
safe_printfmt (1, " (tag of %s)", arch_patch_id_patch_id (tagged));
if (show_cacherevs)
safe_printfmt (1, "%s", " [cached]");
safe_printfmt (1, "\n");
talloc_free (tagged);
}
else
{
for (s = r + 1; s < rel_n_records (revisions); ++s)
{
enum arch_revision_type s_type;
int s_is_cached;
int has_ancestry;
arch_patch_id * pkg_revision_patch;
lim_free (0, package_revision);
package_revision = str_alloc_cat (0, version_stem, revisions[s][0]);
pkg_revision_patch = arch_patch_id_new_archive (arch->official_name, package_revision);
arch_revision_type (&s_type, &s_is_cached, &has_ancestry, arch, pkg_revision_patch);
talloc_free (pkg_revision_patch);
if ((show_cacherevs && (s_is_cached != is_cached))
|| (show_kind && (s_type != this_type)))
break;
}
--s;
if (s == r)
{
safe_printfmt (1, " %s", revisions[r][0]);
}
else
{
safe_printfmt (1, " %s .. %s", revisions[r][0], revisions[s][0]);
}
if (show_kind)
{
safe_printfmt (1, " ");
if (this_type == arch_import_revision)
safe_printfmt (1, "(initial import)");
else
safe_printfmt (1, "(simple changeset)");
}
if (show_cacherevs && is_cached)
safe_printfmt (1, "%s", " [cached]");
safe_printfmt (1, "\n");
r = s;
}
lim_free (0, version_stem);
lim_free (0, package_revision);
talloc_free (pkg_revision_patch);
}
safe_flush (1);
}
else
{
t_uchar * rev = 0;
t_uchar * fqrev = 0;
t_uchar * log = 0;
assoc_table headers = 0;
rev = str_alloc_cat_many (0, versions[v][0], "--", revisions[r][0], str_end);
fqrev = arch_fully_qualify (arch->official_name, rev);
if (!show_kind && !show_cacherevs)
{
safe_printfmt (1, " %s\n", full ? fqrev : revisions[r][0]);
}
else
{
enum arch_revision_type type;
int is_cached;
int has_ancestry;
arch_patch_id * revision = arch_patch_id_new_archive (arch->official_name, rev);
arch_revision_type (&type, &is_cached, &has_ancestry, arch, revision);
safe_printfmt (1, " %s ", full ? fqrev : revisions[r][0]);
if (show_kind)
{
switch (type)
{
case arch_import_revision:
{
safe_printfmt (1, "(initial import)");
talloc_free (revision);
break;
}
case arch_simple_revision:
{
safe_printfmt (1, "(simple changeset)");
talloc_free (revision);
break;
}
case arch_continuation_revision:
{
arch_patch_id * continuation_of = arch_get_continuation (arch, revision);
safe_printfmt (1, "(tag revision of %s)", arch_patch_id_patch_id (continuation_of));
talloc_free (continuation_of);
talloc_free (revision);
break;
}
}
}
if (show_cacherevs && is_cached)
safe_printfmt (1, "%s", " [cached]");
safe_printfmt (1, "\n");
}
log = arch_archive_log (arch, rev);
arch_parse_log (0, &headers, 0, log);
arch_print_headers_summary (1, 10, headers, wanted_headers);
safe_printfmt (1, "\n");
lim_free (0, rev);
lim_free (0, fqrev);
lim_free (0, log);
free_assoc_table (headers);
}
safe_flush (1);
}
if (!omit_empty && (!any_output || !wanted_headers))
safe_printfmt (1, "\n");
lim_free (0, start_at_level);
rel_free_table (revisions);
}
}
rel_free_table (versions);
}
}
rel_free_table (branches);
}
}
rel_free_table (categories);
lim_free (0, last_category_printed);
lim_free (0, last_branch_printed);
lim_free (0, last_version_printed);
}
/****************************************************************
* snap a new since file
*/
if (snap)
{
rel_table unchanged = 0;
rel_table changed = 0;
rel_table all = 0;
int out_fd;
int x;
rel_sort_table_by_field (0, old_since_limits, 0);
rel_sort_table_by_field (0, new_since_limits, 0);
unchanged = rel_join (1, rel_join_output (1,0, 1,1, -1), 0, 0, old_since_limits, new_since_limits);
all = rel_copy_table (new_since_limits);
rel_append_x (&all, unchanged);
arch_sort_table_by_name_field (0, all, 0);
out_fd = safe_open (snap, O_WRONLY | O_CREAT | (snap_force ? 0 : O_EXCL), 0666);
for (x = 0; x < rel_n_records (all); ++x)
{
safe_printfmt (out_fd, "%s--%s\n", all[x][0], all[x][1]);
}
safe_close (out_fd);
rel_free_table (unchanged);
rel_free_table (changed);
rel_free_table (all);
}
lim_free (0, limit_spec);
lim_free (0, limit_category);
lim_free (0, limit_branch);
lim_free (0, limit_version);
lim_free (0, limit_revision);
arch_archive_close (arch);
free_assoc_table (since_limits);
rel_free_table (old_since_limits);
rel_free_table (new_since_limits);
free_assoc_table (limit_categories);
free_assoc_table (limit_branches);
free_assoc_table (limit_versions);
}
return 0;
}
/* tag: Tom Lord Thu Jul 17 10:54:10 2003 (cmd-abrowse.c)
*/
syntax highlighted by Code2HTML, v. 0.9.1