From eae408c064497a222cf6f5f89f2719d3ecdf18f0 Mon Sep 17 00:00:00 2001 From: KatolaZ Date: Fri, 27 Jul 2018 17:33:03 +0100 Subject: repolist working -- towards a proper summary --- cgit_70.c | 2 +- ui_70-log.c | 550 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ ui_70-repolist.c | 2 + ui_70-shared.c | 157 ++++++---------- ui_70-summary.c | 8 +- 5 files changed, 610 insertions(+), 109 deletions(-) create mode 100644 ui_70-log.c diff --git a/cgit_70.c b/cgit_70.c index b2baab0..90ddb6f 100644 --- a/cgit_70.c +++ b/cgit_70.c @@ -384,7 +384,7 @@ static void prepare_context(void) ctx.cfg.renamelimit = -1; ctx.cfg.remove_suffix = 0; ctx.cfg.robots = "index, nofollow"; - ctx.cfg.root_title = "Git repository browser"; + ctx.cfg.root_title = "Git repository browser over Gopher"; ctx.cfg.root_desc = "a fast Gopher interface for the git dscm"; ctx.cfg.scan_hidden_path = 0; ctx.cfg.script_name = CGIT_SCRIPT_NAME; diff --git a/ui_70-log.c b/ui_70-log.c new file mode 100644 index 0000000..d696e20 --- /dev/null +++ b/ui_70-log.c @@ -0,0 +1,550 @@ +/* ui-log.c: functions for log output + * + * Copyright (C) 2006-2014 cgit Development Team + * + * Licensed under GNU General Public License v2 + * (see COPYING for full license text) + */ + +#include "cgit.h" +#include "ui-log.h" +#include "html.h" +#include "ui-shared.h" +#include "argv-array.h" + +static int files, add_lines, rem_lines, lines_counted; + +/* + * The list of available column colors in the commit graph. + */ +static const char *column_colors_html[] = { + "", + "", + "", + "", + "", + "", + "", +}; + +#define COLUMN_COLORS_HTML_MAX (ARRAY_SIZE(column_colors_html) - 1) + +static void count_lines(char *line, int size) +{ + if (size <= 0) + return; + + if (line[0] == '+') + add_lines++; + + else if (line[0] == '-') + rem_lines++; +} + +static void inspect_files(struct diff_filepair *pair) +{ + unsigned long old_size = 0; + unsigned long new_size = 0; + int binary = 0; + + files++; + if (ctx.repo->enable_log_linecount) + cgit_diff_files(&pair->one->oid, &pair->two->oid, &old_size, + &new_size, &binary, 0, ctx.qry.ignorews, + count_lines); +} + +void show_commit_decorations(struct commit *commit) +{ + const struct name_decoration *deco; + static char buf[1024]; + + buf[sizeof(buf) - 1] = 0; + deco = get_name_decoration(&commit->object); + if (!deco) + return; + html(""); + while (deco) { + struct object_id peeled; + int is_annotated = 0; + strncpy(buf, prettify_refname(deco->name), sizeof(buf) - 1); + switch(deco->type) { + case DECORATION_NONE: + /* If the git-core doesn't recognize it, + * don't display anything. */ + break; + case DECORATION_REF_LOCAL: + cgit_log_link(buf, NULL, "branch-deco", buf, NULL, + ctx.qry.vpath, 0, NULL, NULL, + ctx.qry.showmsg, 0); + break; + case DECORATION_REF_TAG: + if (!peel_ref(deco->name, &peeled)) + is_annotated = !oidcmp(&commit->object.oid, &peeled); + cgit_tag_link(buf, NULL, is_annotated ? "tag-annotated-deco" : "tag-deco", buf); + break; + case DECORATION_REF_REMOTE: + if (!ctx.repo->enable_remote_branches) + break; + cgit_log_link(buf, NULL, "remote-deco", NULL, + oid_to_hex(&commit->object.oid), + ctx.qry.vpath, 0, NULL, NULL, + ctx.qry.showmsg, 0); + break; + default: + cgit_commit_link(buf, NULL, "deco", ctx.qry.head, + oid_to_hex(&commit->object.oid), + ctx.qry.vpath); + break; + } + deco = deco->next; + } + html(""); +} + +static void handle_rename(struct diff_filepair *pair) +{ + /* + * After we have seen a rename, we generate links to the previous + * name of the file so that commit & diff views get fed the path + * that is correct for the commit they are showing, avoiding the + * need to walk the entire history leading back to every commit we + * show in order detect renames. + */ + if (0 != strcmp(ctx.qry.vpath, pair->two->path)) { + free(ctx.qry.vpath); + ctx.qry.vpath = xstrdup(pair->two->path); + } + inspect_files(pair); +} + +static int show_commit(struct commit *commit, struct rev_info *revs) +{ + struct commit_list *parents = commit->parents; + struct commit *parent; + int found = 0, saved_fmt; + struct diff_flags saved_flags = revs->diffopt.flags; + + /* Always show if we're not in "follow" mode with a single file. */ + if (!ctx.qry.follow) + return 1; + + /* + * In "follow" mode, we don't show merges. This is consistent with + * "git log --follow -- ". + */ + if (parents && parents->next) + return 0; + + /* + * If this is the root commit, do what rev_info tells us. + */ + if (!parents) + return revs->show_root_diff; + + /* When we get here we have precisely one parent. */ + parent = parents->item; + /* If we can't parse the commit, let print_commit() report an error. */ + if (parse_commit(parent)) + return 1; + + files = 0; + add_lines = 0; + rem_lines = 0; + + revs->diffopt.flags.recursive = 1; + diff_tree_oid(&parent->maybe_tree->object.oid, + &commit->maybe_tree->object.oid, + "", &revs->diffopt); + diffcore_std(&revs->diffopt); + + found = !diff_queue_is_empty(); + saved_fmt = revs->diffopt.output_format; + revs->diffopt.output_format = DIFF_FORMAT_CALLBACK; + revs->diffopt.format_callback = cgit_diff_tree_cb; + revs->diffopt.format_callback_data = handle_rename; + diff_flush(&revs->diffopt); + revs->diffopt.output_format = saved_fmt; + revs->diffopt.flags = saved_flags; + + lines_counted = 1; + return found; +} + +static void print_commit(struct commit *commit, struct rev_info *revs) +{ + struct commitinfo *info; + int columns = revs->graph ? 4 : 3; + struct strbuf graphbuf = STRBUF_INIT; + struct strbuf msgbuf = STRBUF_INIT; + + if (ctx.repo->enable_log_filecount) + columns++; + if (ctx.repo->enable_log_linecount) + columns++; + + if (revs->graph) { + /* Advance graph until current commit */ + while (!graph_next_line(revs->graph, &graphbuf)) { + /* Print graph segment in otherwise empty table row */ + html(""); + html(graphbuf.buf); + htmlf("\n", columns); + strbuf_setlen(&graphbuf, 0); + } + /* Current commit's graph segment is now ready in graphbuf */ + } + + info = cgit_parse_commit(commit); + htmlf("", ctx.qry.showmsg ? " class='logheader'" : ""); + + if (revs->graph) { + /* Print graph segment for current commit */ + html(""); + html(graphbuf.buf); + html(""); + strbuf_setlen(&graphbuf, 0); + } + else { + html(""); + cgit_print_age(info->committer_date, info->committer_tz, TM_WEEK * 2); + html(""); + } + + htmlf("", ctx.qry.showmsg ? " class='logsubject'" : ""); + if (ctx.qry.showmsg) { + /* line-wrap long commit subjects instead of truncating them */ + size_t subject_len = strlen(info->subject); + + if (subject_len > ctx.cfg.max_msg_len && + ctx.cfg.max_msg_len >= 15) { + /* symbol for signaling line-wrap (in PAGE_ENCODING) */ + const char wrap_symbol[] = { ' ', 0xE2, 0x86, 0xB5, 0 }; + int i = ctx.cfg.max_msg_len - strlen(wrap_symbol); + + /* Rewind i to preceding space character */ + while (i > 0 && !isspace(info->subject[i])) + --i; + if (!i) /* Oops, zero spaces. Reset i */ + i = ctx.cfg.max_msg_len - strlen(wrap_symbol); + + /* add remainder starting at i to msgbuf */ + strbuf_add(&msgbuf, info->subject + i, subject_len - i); + strbuf_trim(&msgbuf); + strbuf_add(&msgbuf, "\n\n", 2); + + /* Place wrap_symbol at position i in info->subject */ + strcpy(info->subject + i, wrap_symbol); + } + } + cgit_commit_link(info->subject, NULL, NULL, ctx.qry.head, + oid_to_hex(&commit->object.oid), ctx.qry.vpath); + show_commit_decorations(commit); + html(""); + cgit_open_filter(ctx.repo->email_filter, info->author_email, "log"); + html_txt(info->author); + cgit_close_filter(ctx.repo->email_filter); + + if (revs->graph) { + html(""); + cgit_print_age(info->committer_date, info->committer_tz, TM_WEEK * 2); + } + + if (!lines_counted && (ctx.repo->enable_log_filecount || + ctx.repo->enable_log_linecount)) { + files = 0; + add_lines = 0; + rem_lines = 0; + cgit_diff_commit(commit, inspect_files, ctx.qry.vpath); + } + + if (ctx.repo->enable_log_filecount) + htmlf("%d", files); + if (ctx.repo->enable_log_linecount) + htmlf("-%d/" + "+%d", rem_lines, add_lines); + + html("\n"); + + if ((revs->graph && !graph_is_commit_finished(revs->graph)) + || ctx.qry.showmsg) { /* Print a second table row */ + html(""); + + if (ctx.qry.showmsg) { + /* Concatenate commit message + notes in msgbuf */ + if (info->msg && *(info->msg)) { + strbuf_addstr(&msgbuf, info->msg); + strbuf_addch(&msgbuf, '\n'); + } + format_display_notes(&commit->object.oid, + &msgbuf, PAGE_ENCODING, 0); + strbuf_addch(&msgbuf, '\n'); + strbuf_ltrim(&msgbuf); + } + + if (revs->graph) { + int lines = 0; + + /* Calculate graph padding */ + if (ctx.qry.showmsg) { + /* Count #lines in commit message + notes */ + const char *p = msgbuf.buf; + lines = 1; + while ((p = strchr(p, '\n'))) { + p++; + lines++; + } + } + + /* Print graph padding */ + html(""); + while (lines > 0 || !graph_is_commit_finished(revs->graph)) { + if (graphbuf.len) + html("\n"); + strbuf_setlen(&graphbuf, 0); + graph_next_line(revs->graph, &graphbuf); + html(graphbuf.buf); + lines--; + } + html("\n"); + } + else + html(""); /* Empty 'Age' column */ + + /* Print msgbuf into remainder of table row */ + htmlf("\n", columns - (revs->graph ? 1 : 0), + ctx.qry.showmsg ? " class='logmsg'" : ""); + html_txt(msgbuf.buf); + html("\n"); + } + + strbuf_release(&msgbuf); + strbuf_release(&graphbuf); + cgit_free_commitinfo(info); +} + +static const char *disambiguate_ref(const char *ref, int *must_free_result) +{ + struct object_id oid; + struct strbuf longref = STRBUF_INIT; + + strbuf_addf(&longref, "refs/heads/%s", ref); + if (get_oid(longref.buf, &oid) == 0) { + *must_free_result = 1; + return strbuf_detach(&longref, NULL); + } + + *must_free_result = 0; + strbuf_release(&longref); + return ref; +} + +static char *next_token(char **src) +{ + char *result; + + if (!src || !*src) + return NULL; + while (isspace(**src)) + (*src)++; + if (!**src) + return NULL; + result = *src; + while (**src) { + if (isspace(**src)) { + **src = '\0'; + (*src)++; + break; + } + (*src)++; + } + return result; +} + +void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern, + char *path, int pager, int commit_graph, int commit_sort) +{ + struct rev_info rev; + struct commit *commit; + struct argv_array rev_argv = ARGV_ARRAY_INIT; + int i, columns = commit_graph ? 4 : 3; + int must_free_tip = 0; + + /* rev_argv.argv[0] will be ignored by setup_revisions */ + argv_array_push(&rev_argv, "log_rev_setup"); + + if (!tip) + tip = ctx.qry.head; + tip = disambiguate_ref(tip, &must_free_tip); + argv_array_push(&rev_argv, tip); + + if (grep && pattern && *pattern) { + pattern = xstrdup(pattern); + if (!strcmp(grep, "grep") || !strcmp(grep, "author") || + !strcmp(grep, "committer")) { + argv_array_pushf(&rev_argv, "--%s=%s", grep, pattern); + } else if (!strcmp(grep, "range")) { + char *arg; + /* Split the pattern at whitespace and add each token + * as a revision expression. Do not accept other + * rev-list options. Also, replace the previously + * pushed tip (it's no longer relevant). + */ + argv_array_pop(&rev_argv); + while ((arg = next_token(&pattern))) { + if (*arg == '-') { + fprintf(stderr, "Bad range expr: %s\n", + arg); + break; + } + argv_array_push(&rev_argv, arg); + } + } + } + + if (!path || !ctx.cfg.enable_follow_links) { + /* + * If we don't have a path, "follow" is a no-op so make sure + * the variable is set to false to avoid needing to check + * both this and whether we have a path everywhere. + */ + ctx.qry.follow = 0; + } + + if (commit_graph && !ctx.qry.follow) { + argv_array_push(&rev_argv, "--graph"); + argv_array_push(&rev_argv, "--color"); + graph_set_column_colors(column_colors_html, + COLUMN_COLORS_HTML_MAX); + } + + if (commit_sort == 1) + argv_array_push(&rev_argv, "--date-order"); + else if (commit_sort == 2) + argv_array_push(&rev_argv, "--topo-order"); + + if (path && ctx.qry.follow) + argv_array_push(&rev_argv, "--follow"); + argv_array_push(&rev_argv, "--"); + if (path) + argv_array_push(&rev_argv, path); + + init_revisions(&rev, NULL); + rev.abbrev = DEFAULT_ABBREV; + rev.commit_format = CMIT_FMT_DEFAULT; + rev.verbose_header = 1; + rev.show_root_diff = 0; + rev.ignore_missing = 1; + rev.simplify_history = 1; + setup_revisions(rev_argv.argc, rev_argv.argv, &rev, NULL); + load_ref_decorations(NULL, DECORATE_FULL_REFS); + rev.show_decorations = 1; + rev.grep_filter.ignore_case = 1; + + rev.diffopt.detect_rename = 1; + rev.diffopt.rename_limit = ctx.cfg.renamelimit; + if (ctx.qry.ignorews) + DIFF_XDL_SET(&rev.diffopt, IGNORE_WHITESPACE); + + compile_grep_patterns(&rev.grep_filter); + prepare_revision_walk(&rev); + + if (pager) { + cgit_print_layout_start(); + html(""); + } + + html(""); + if (commit_graph) + html(""); + else + html(""); + html(""); + if (rev.graph) + html(""); + if (ctx.repo->enable_log_filecount) { + html(""); + columns++; + } + if (ctx.repo->enable_log_linecount) { + html(""); + columns++; + } + html("\n"); + + if (ofs<0) + ofs = 0; + + for (i = 0; i < ofs && (commit = get_revision(&rev)) != NULL; /* nop */) { + if (show_commit(commit, &rev)) + i++; + free_commit_buffer(commit); + free_commit_list(commit->parents); + commit->parents = NULL; + } + + for (i = 0; i < cnt && (commit = get_revision(&rev)) != NULL; /* nop */) { + /* + * In "follow" mode, we must count the files and lines the + * first time we invoke diff on a given commit, and we need + * to do that to see if the commit touches the path we care + * about, so we do it in show_commit. Hence we must clear + * lines_counted here. + * + * This has the side effect of avoiding running diff twice + * when we are both following renames and showing file + * and/or line counts. + */ + lines_counted = 0; + if (show_commit(commit, &rev)) { + i++; + print_commit(commit, &rev); + } + free_commit_buffer(commit); + free_commit_list(commit->parents); + commit->parents = NULL; + } + if (pager) { + html("
AgeCommit message"); + if (pager) { + html(" ("); + cgit_log_link(ctx.qry.showmsg ? "Collapse" : "Expand", NULL, + NULL, ctx.qry.head, ctx.qry.sha1, + ctx.qry.vpath, ctx.qry.ofs, ctx.qry.grep, + ctx.qry.search, ctx.qry.showmsg ? 0 : 1, + ctx.qry.follow); + html(")"); + } + html("AuthorAgeFilesLines
    "); + if (ofs > 0) { + html("
  • "); + cgit_log_link("[prev]", NULL, NULL, ctx.qry.head, + ctx.qry.sha1, ctx.qry.vpath, + ofs - cnt, ctx.qry.grep, + ctx.qry.search, ctx.qry.showmsg, + ctx.qry.follow); + html("
    • "); + } + if ((commit = get_revision(&rev)) != NULL) { + html("
  • "); + cgit_log_link("[next]", NULL, NULL, ctx.qry.head, + ctx.qry.sha1, ctx.qry.vpath, + ofs + cnt, ctx.qry.grep, + ctx.qry.search, ctx.qry.showmsg, + ctx.qry.follow); + html("
    • "); + } + html("
"); + cgit_print_layout_end(); + } else if ((commit = get_revision(&rev)) != NULL) { + htmlf("", columns); + cgit_log_link("[...]", NULL, NULL, ctx.qry.head, NULL, + ctx.qry.vpath, 0, NULL, NULL, ctx.qry.showmsg, + ctx.qry.follow); + html("\n"); + } + + /* If we allocated tip then it is safe to cast away const. */ + if (must_free_tip) + free((char*) tip); +} diff --git a/ui_70-repolist.c b/ui_70-repolist.c index e03acb5..7a4e6ae 100644 --- a/ui_70-repolist.c +++ b/ui_70-repolist.c @@ -263,6 +263,8 @@ void cgit_print_repolist(void) sorted = sort_repolist(ctx.qry.sort); else if (ctx.cfg.section_sort) sort_repolist("section"); + + cgit_print_layout_start(); print_header(); for (i = 0; i < cgit_repolist.count; i++) { diff --git a/ui_70-shared.c b/ui_70-shared.c index 990143c..30a1eaf 100644 --- a/ui_70-shared.c +++ b/ui_70-shared.c @@ -56,6 +56,10 @@ void cgit_gopher_text(const char *txt){ printf("%s", txt); } +void cgit_gopher_tab(){ + printf("\t"); +} + void gopher_vtxtf(const char *format, va_list ap) { @@ -207,18 +211,18 @@ char *cgit_currenturl(void) size_t len = strlen(root); if (!ctx.qry.url) - return xstrdup(root); + return fmtalloc("/%s", root); if (len && root[len - 1] == '/') - return fmtalloc("%s%s", root, ctx.qry.url); - return fmtalloc("%s/%s", root, ctx.qry.url); + return fmtalloc("/%s%s", root, ctx.qry.url); + return fmtalloc("/%s/%s", root, ctx.qry.url); } const char *cgit_rooturl(void) { if (ctx.cfg.virtual_root) - return ctx.cfg.virtual_root; + return fmtalloc("/%s", ctx.cfg.virtual_root); else - return ctx.cfg.script_name; + return fmtalloc("/%s", ctx.cfg.script_name); } const char *cgit_loginurl(void) @@ -305,55 +309,47 @@ static void site_url(const char *page, const char *search, const char *sort, int { char *delim = "?"; - if (always_root || page) - html_attr(cgit_rooturl()); + if (always_root || page){ + + cgit_gopher_text(cgit_rooturl()); + } else { char *currenturl = cgit_currenturl(); - html_attr(currenturl); + cgit_gopher_text(currenturl); free(currenturl); } if (page) { - htmlf("?p=%s", page); - delim = "&"; + cgit_gopher_textf("?p=%s", page); + delim = "&"; } if (search) { - html(delim); - html("q="); - html_attr(search); - delim = "&"; + cgit_gopher_text(delim); + cgit_gopher_text("q="); + cgit_gopher_text(search); + delim = "&"; } if (sort) { - html(delim); - html("s="); - html_attr(sort); - delim = "&"; + cgit_gopher_text(delim); + cgit_gopher_text("s="); + cgit_gopher_text(sort); + delim = "&"; } if (ofs) { - html(delim); - htmlf("ofs=%d", ofs); + cgit_gopher_text(delim); + cgit_gopher_textf("ofs=%d", ofs); } } static void site_link(const char *page, const char *name, const char *title, const char *class, const char *search, const char *sort, int ofs, int always_root) { - html(""); - html_txt(name); - html(""); + cgit_gopher_tab(); + cgit_gopher_end_selector(); } void cgit_index_link(const char *name, const char *title, const char *class, @@ -458,13 +454,18 @@ static void reporevlink(const char *page, const char *name, const char *title, cgit_gopher_text("id="); cgit_gopher_text(rev); } - cgit_gopher_text("\t"); + cgit_gopher_tab(); } void cgit_summary_link(const char *name, const char *title, const char *class, const char *head) { + + cgit_gopher_start_selector(GOPHER_MENU); + cgit_gopher_text(name); + cgit_gopher_tab(); reporevlink(NULL, name, title, class, head, NULL, NULL); + cgit_gopher_end_selector(); } void cgit_tag_link(const char *name, const char *title, const char *class, @@ -578,7 +579,11 @@ void cgit_commit_link(const char *name, const char *title, const char *class, void cgit_refs_link(const char *name, const char *title, const char *class, const char *head, const char *rev, const char *path) { + cgit_gopher_start_selector(GOPHER_MENU); + cgit_gopher_text(name); + cgit_gopher_tab(); reporevlink("refs", name, title, class, head, rev, path); + cgit_gopher_end_selector(); } void cgit_snapshot_link(const char *name, const char *title, const char *class, @@ -950,8 +955,8 @@ void cgit_print_error_page(int code, const char *msg, const char *fmt, ...) void cgit_print_layout_start(void) { - cgit_print_http_headers(); - cgit_print_docstart(); + /*cgit_print_http_headers(); + cgit_print_docstart();*/ cgit_print_pageheader(); } @@ -1054,73 +1059,32 @@ static void cgit_print_path_crumbs(char *path) ctx.qry.path = old_path; } -static void print_header(void) -{ - char *logo = NULL, *logo_link = NULL; - html("\n"); - html("\n"); - if (ctx.repo && ctx.repo->logo && *ctx.repo->logo) - logo = ctx.repo->logo; - else - logo = ctx.cfg.logo; - if (ctx.repo && ctx.repo->logo_link && *ctx.repo->logo_link) - logo_link = ctx.repo->logo_link; - else - logo_link = ctx.cfg.logo_link; - if (logo && *logo) { - html("\n"); - } - html("\n"); - - html("\n"); } void cgit_print_pageheader(void) { - html("
"); if (!ctx.env.authenticated || !ctx.cfg.noheader) print_header(); - html("
\n"); - if (ctx.env.authenticated && ctx.repo) { + if (ctx.repo) { if (ctx.repo->readme.nr) reporevlink("about", "about", NULL, hc("about"), ctx.qry.head, NULL, @@ -1158,19 +1122,6 @@ void cgit_print_pageheader(void) html_url_path(fileurl); free(fileurl); } - html("'>\n"); - cgit_add_hidden_formfields(1, 0, "log"); - html("\n"); - html("\n"); - html("\n"); - html("\n"); } else if (ctx.env.authenticated) { char *currenturl = cgit_currenturl(); site_link(NULL, "index", NULL, hc("repolist"), NULL, NULL, 0, 1); @@ -1188,7 +1139,6 @@ void cgit_print_pageheader(void) html(""); free(currenturl); } - html("
\n"); if (ctx.env.authenticated && ctx.repo && ctx.qry.vpath) { html("
"); html("path: "); @@ -1203,7 +1153,6 @@ void cgit_print_pageheader(void) } html("
"); } - html("
"); } void cgit_print_filemode(unsigned short mode) diff --git a/ui_70-summary.c b/ui_70-summary.c index 4140446..e398e50 100644 --- a/ui_70-summary.c +++ b/ui_70-summary.c @@ -44,6 +44,7 @@ void cgit_print_summary(void) { int columns = 3; + cgit_print_layout_start(); if (ctx.repo->enable_log_filecount) columns++; if (ctx.repo->enable_log_linecount) @@ -52,15 +53,14 @@ void cgit_print_summary(void) cgit_print_branches(ctx.cfg.summary_branches); cgit_print_tags(ctx.cfg.summary_tags); - if (ctx.cfg.summary_log > 0) { + /* FIXME: removed log -- reintroduce it as soon as we have a working cgit_print_log */ +/* if (ctx.cfg.summary_log > 0) { htmlf(" ", columns); cgit_print_log(ctx.qry.head, 0, ctx.cfg.summary_log, NULL, NULL, NULL, 0, 0, 0); } +*/ urls = 0; - cgit_add_clone_urls(print_url); - html(""); - cgit_print_layout_end(); } /* The caller must free the return value. */ -- cgit v1.2.3