Add ui-shared.h

This is finally a proper headerfile for the shared ui-functions which
used to reside in cgit.h

Signed-off-by: Lars Hjemli <hjemli@gmail.com>

13 files changed, 47 insertions, 32 deletions

diff --git a/cgit.c b/cgit.c
index 79e0e43..dbb023e 100644
--- a/cgit.c
+++ b/cgit.c
@@ -1,58 +1,59 @@
 /* cgit.c: cgi for the git scm
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 #include "cmd.h"
+#include "ui-shared.h"
 
 static int cgit_prepare_cache(struct cacheitem *item)
 {
         if (!ctx.repo && ctx.qry.repo) {
                 ctx.page.title = fmt("%s - %s", ctx.cfg.root_title,
                                       "Bad request");
                 cgit_print_http_headers(&ctx);
                 cgit_print_docstart(&ctx);
                 cgit_print_pageheader(&ctx);
                 cgit_print_error(fmt("Unknown repo: %s", ctx.qry.repo));
                 cgit_print_docend();
                 return 0;
         }
 
         if (!ctx.repo) {
                 item->name = xstrdup(fmt("%s/index.html", ctx.cfg.cache_root));
                 item->ttl = ctx.cfg.cache_root_ttl;
                 return 1;
         }
 
         if (!cgit_cmd) {
                 item->name = xstrdup(fmt("%s/%s/index.%s.html", ctx.cfg.cache_root,
                                          cache_safe_filename(ctx.repo->url),
                                          cache_safe_filename(ctx.qry.raw)));
                 item->ttl = ctx.cfg.cache_repo_ttl;
         } else {
                 item->name = xstrdup(fmt("%s/%s/%s/%s.html", ctx.cfg.cache_root,
                                          cache_safe_filename(ctx.repo->url),
                                          ctx.qry.page,
                                          cache_safe_filename(ctx.qry.raw)));
                 if (ctx.qry.has_symref)
                         item->ttl = ctx.cfg.cache_dynamic_ttl;
                 else if (ctx.qry.has_sha1)
                         item->ttl = ctx.cfg.cache_static_ttl;
                 else
                         item->ttl = ctx.cfg.cache_repo_ttl;
         }
         return 1;
 }
 
 struct refmatch {
         char *req_ref;
         char *first_ref;
         int match;
 };
 
 int find_current_ref(const char *refname, const unsigned char *sha1,
                      int flags, void *cb_data)
diff --git a/cgit.h b/cgit.h
index 1b23369..c1a231d 100644
--- a/cgit.h
+++ b/cgit.h
@@ -192,85 +192,53 @@ extern const struct cgit_snapshot_format cgit_snapshot_formats[];
 extern int cgit_cmd;
 
 extern void cgit_prepare_context(struct cgit_context *ctx);
 extern struct cgit_repo *cgit_get_repoinfo(const char *url);
 extern void cgit_global_config_cb(const char *name, const char *value);
 extern void cgit_repo_config_cb(const char *name, const char *value);
 extern void cgit_querystring_cb(const char *name, const char *value);
 
 extern int chk_zero(int result, char *msg);
 extern int chk_positive(int result, char *msg);
 extern int chk_non_negative(int result, char *msg);
 
 extern int hextoint(char c);
 extern char *trim_end(const char *str, char c);
 extern char *strlpart(char *txt, int maxlen);
 extern char *strrpart(char *txt, int maxlen);
 
 extern void cgit_add_ref(struct reflist *list, struct refinfo *ref);
 extern int cgit_refs_cb(const char *refname, const unsigned char *sha1,
                         int flags, void *cb_data);
 
 extern void *cgit_free_commitinfo(struct commitinfo *info);
 
 extern int cgit_diff_files(const unsigned char *old_sha1,
                            const unsigned char *new_sha1,
                            linediff_fn fn);
 
 extern void cgit_diff_tree(const unsigned char *old_sha1,
                            const unsigned char *new_sha1,
                            filepair_fn fn, const char *prefix);
 
 extern void cgit_diff_commit(struct commit *commit, filepair_fn fn);
 
 extern char *fmt(const char *format,...);
 
 extern int cgit_read_config(const char *filename, configfn fn);
 extern int cgit_parse_query(char *txt, configfn fn);
 extern struct commitinfo *cgit_parse_commit(struct commit *commit);
 extern struct taginfo *cgit_parse_tag(struct tag *tag);
 extern void cgit_parse_url(const char *url);
 
 extern char *cache_safe_filename(const char *unsafe);
 extern int cache_lock(struct cacheitem *item);
 extern int cache_unlock(struct cacheitem *item);
 extern int cache_cancel_lock(struct cacheitem *item);
 extern int cache_exist(struct cacheitem *item);
 extern int cache_expired(struct cacheitem *item);
 
-extern char *cgit_repourl(const char *reponame);
-extern char *cgit_fileurl(const char *reponame, const char *pagename,
-                          const char *filename, const char *query);
-extern char *cgit_pageurl(const char *reponame, const char *pagename,
-                          const char *query);
-
 extern const char *cgit_repobasename(const char *reponame);
 
-extern void cgit_tree_link(char *name, char *title, char *class, char *head,
-                           char *rev, char *path);
-extern void cgit_log_link(char *name, char *title, char *class, char *head,
-                          char *rev, char *path, int ofs, char *grep,
-                          char *pattern);
-extern void cgit_commit_link(char *name, char *title, char *class, char *head,
-                             char *rev);
-extern void cgit_refs_link(char *name, char *title, char *class, char *head,
-                           char *rev, char *path);
-extern void cgit_snapshot_link(char *name, char *title, char *class,
-                               char *head, char *rev, char *archivename);
-extern void cgit_diff_link(char *name, char *title, char *class, char *head,
-                           char *new_rev, char *old_rev, char *path);
-
-extern void cgit_object_link(struct object *obj);
-
-extern void cgit_print_error(char *msg);
-extern void cgit_print_date(time_t secs, char *format);
-extern void cgit_print_age(time_t t, time_t max_relative, char *format);
-extern void cgit_print_http_headers(struct cgit_context *ctx);
-extern void cgit_print_docstart(struct cgit_context *ctx);
-extern void cgit_print_docend();
-extern void cgit_print_pageheader(struct cgit_context *ctx);
-extern void cgit_print_filemode(unsigned short mode);
-extern void cgit_print_snapshot_links(const char *repo, const char *head,
-                                      const char *hex, int snapshots);
 extern int cgit_parse_snapshots_mask(const char *str);
 
 #endif /* CGIT_H */
diff --git a/ui-blob.c b/ui-blob.c
index 3b29132..11589db 100644
--- a/ui-blob.c
+++ b/ui-blob.c
@@ -1,42 +1,43 @@
 /* ui-blob.c: show blob content
  *
  * Copyright (C) 2008 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 #include "html.h"
+#include "ui-shared.h"
 
 void cgit_print_blob(const char *hex, char *path)
 {
 
         unsigned char sha1[20];
         enum object_type type;
         unsigned char *buf;
         unsigned long size;
 
         if (get_sha1_hex(hex, sha1)){
                 cgit_print_error(fmt("Bad hex value: %s", hex));
                 return;
         }
 
         type = sha1_object_info(sha1, &size);
         if (type == OBJ_BAD) {
                 cgit_print_error(fmt("Bad object name: %s", hex));
                 return;
         }
 
         buf = read_sha1_file(sha1, &type, &size);
         if (!buf) {
                 cgit_print_error(fmt("Error reading object %s", hex));
                 return;
         }
 
         buf[size] = '\0';
         ctx.page.mimetype = "text/plain";
         ctx.page.filename = path;
         cgit_print_http_headers(&ctx);
         write(htmlfd, buf, size);
 }
diff --git a/ui-commit.c b/ui-commit.c
index ed25824..8019e36 100644
--- a/ui-commit.c
+++ b/ui-commit.c
@@ -1,58 +1,59 @@
 /* ui-commit.c: generate commit view
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 #include "html.h"
+#include "ui-shared.h"
 
 static int files, slots;
 static int total_adds, total_rems, max_changes;
 static int lines_added, lines_removed;
 static char *curr_rev;
 
 static struct fileinfo {
         char status;
         unsigned char old_sha1[20];
         unsigned char new_sha1[20];
         unsigned short old_mode;
         unsigned short new_mode;
         char *old_path;
         char *new_path;
         unsigned int added;
         unsigned int removed;
 } *items;
 
 
 void print_fileinfo(struct fileinfo *info)
 {
         char *class;
 
         switch (info->status) {
         case DIFF_STATUS_ADDED:
                 class = "add";
                 break;
         case DIFF_STATUS_COPIED:
                 class = "cpy";
                 break;
         case DIFF_STATUS_DELETED:
                 class = "del";
                 break;
         case DIFF_STATUS_MODIFIED:
                 class = "upd";
                 break;
         case DIFF_STATUS_RENAMED:
                 class = "mov";
                 break;
         case DIFF_STATUS_TYPE_CHANGED:
                 class = "typ";
                 break;
         case DIFF_STATUS_UNKNOWN:
                 class = "unk";
                 break;
         case DIFF_STATUS_UNMERGED:
                 class = "stg";
                 break;
diff --git a/ui-diff.c b/ui-diff.c
index 5c3bc98..2a22009 100644
--- a/ui-diff.c
+++ b/ui-diff.c
@@ -1,58 +1,59 @@
 /* ui-diff.c: show diff between two blobs
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 #include "html.h"
+#include "ui-shared.h"
 
 unsigned char old_rev_sha1[20];
 unsigned char new_rev_sha1[20];
 
 /*
  * print a single line returned from xdiff
  */
 static void print_line(char *line, int len)
 {
         char *class = "ctx";
         char c = line[len-1];
 
         if (line[0] == '+')
                 class = "add";
         else if (line[0] == '-')
                 class = "del";
         else if (line[0] == '@')
                 class = "hunk";
 
         htmlf("<div class='%s'>", class);
         line[len-1] = '\0';
         html_txt(line);
         html("</div>");
         line[len-1] = c;
 }
 
 static void header(unsigned char *sha1, char *path1, int mode1,
                    unsigned char *sha2, char *path2, int mode2)
 {
         char *abbrev1, *abbrev2;
         int subproject;
 
         subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2));
         html("<div class='head'>");
         html("diff --git a/");
         html_txt(path1);
         html(" b/");
         html_txt(path2);
 
         if (is_null_sha1(sha1))
                 path1 = "dev/null";
         if (is_null_sha1(sha2))
                 path2 = "dev/null";
 
         if (mode1 == 0)
                 htmlf("<br/>new file mode %.6o", mode2);
 
         if (mode2 == 0)
diff --git a/ui-log.c b/ui-log.c
index e1d324d..60c9269 100644
--- a/ui-log.c
+++ b/ui-log.c
@@ -1,58 +1,59 @@
 /* ui-log.c: functions for log output
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 #include "html.h"
+#include "ui-shared.h"
 
 int files, add_lines, rem_lines;
 
 void count_lines(char *line, int size)
 {
         if (size <= 0)
                 return;
 
         if (line[0] == '+')
                 add_lines++;
 
         else if (line[0] == '-')
                 rem_lines++;
 }
 
 void inspect_files(struct diff_filepair *pair)
 {
         files++;
         if (ctx.repo->enable_log_linecount)
                 cgit_diff_files(pair->one->sha1, pair->two->sha1, count_lines);
 }
 
 void print_commit(struct commit *commit)
 {
         struct commitinfo *info;
 
         info = cgit_parse_commit(commit);
         html("<tr><td>");
         cgit_print_age(commit->date, TM_WEEK * 2, FMT_SHORTDATE);
         html("</td><td>");
         cgit_commit_link(info->subject, NULL, NULL, ctx.qry.head,
                          sha1_to_hex(commit->object.sha1));
         if (ctx.repo->enable_log_filecount) {
                 files = 0;
                 add_lines = 0;
                 rem_lines = 0;
                 cgit_diff_commit(commit, inspect_files);
                 html("</td><td class='right'>");
                 htmlf("%d", files);
                 if (ctx.repo->enable_log_linecount) {
                         html("</td><td class='right'>");
                         htmlf("-%d/+%d", rem_lines, add_lines);
                 }
         }
         html("</td><td>");
         html_txt(info->author);
         html("</td></tr>\n");
         cgit_free_commitinfo(info);
diff --git a/ui-patch.c b/ui-patch.c
index 68ebb15..36bfae4 100644
--- a/ui-patch.c
+++ b/ui-patch.c
@@ -1,58 +1,59 @@
 /* ui-patch.c: generate patch view
  *
  * Copyright (C) 2007 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 #include "html.h"
+#include "ui-shared.h"
 
 static void print_line(char *line, int len)
 {
         char c = line[len-1];
 
         line[len-1] = '\0';
         htmlf("%s\n", line);
         line[len-1] = c;
 }
 
 static void header(unsigned char *sha1, char *path1, int mode1,
                    unsigned char *sha2, char *path2, int mode2)
 {
         char *abbrev1, *abbrev2;
         int subproject;
 
         subproject = (S_ISGITLINK(mode1) || S_ISGITLINK(mode2));
         htmlf("diff --git a/%s b/%s\n", path1, path2);
 
         if (is_null_sha1(sha1))
                 path1 = "dev/null";
         if (is_null_sha1(sha2))
                 path2 = "dev/null";
 
         if (mode1 == 0)
                 htmlf("new file mode %.6o\n", mode2);
 
         if (mode2 == 0)
                 htmlf("deleted file mode %.6o\n", mode1);
 
         if (!subproject) {
                 abbrev1 = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV));
                 abbrev2 = xstrdup(find_unique_abbrev(sha2, DEFAULT_ABBREV));
                 htmlf("index %s..%s", abbrev1, abbrev2);
                 free(abbrev1);
                 free(abbrev2);
                 if (mode1 != 0 && mode2 != 0) {
                         htmlf(" %.6o", mode1);
                         if (mode2 != mode1)
                                 htmlf("..%.6o", mode2);
                 }
                 htmlf("\n--- a/%s\n", path1);
                 htmlf("+++ b/%s\n", path2);
         }
 }
 
 static void filepair_cb(struct diff_filepair *pair)
 {
diff --git a/ui-refs.c b/ui-refs.c
index fc82ca7..12533cd 100644
--- a/ui-refs.c
+++ b/ui-refs.c
@@ -1,58 +1,59 @@
 /* ui-refs.c: browse symbolic refs
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 #include "html.h"
+#include "ui-shared.h"
 
 static int header;
 
 static int cmp_age(int age1, int age2)
 {
         if (age1 != 0 && age2 != 0)
                 return age2 - age1;
 
         if (age1 == 0 && age2 == 0)
                 return 0;
 
         if (age1 == 0)
                 return +1;
 
         return -1;
 }
 
 static int cmp_ref_name(const void *a, const void *b)
 {
         struct refinfo *r1 = *(struct refinfo **)a;
         struct refinfo *r2 = *(struct refinfo **)b;
 
         return strcmp(r1->refname, r2->refname);
 }
 
 static int cmp_branch_age(const void *a, const void *b)
 {
         struct refinfo *r1 = *(struct refinfo **)a;
         struct refinfo *r2 = *(struct refinfo **)b;
 
         return cmp_age(r1->commit->committer_date, r2->commit->committer_date);
 }
 
 static int cmp_tag_age(const void *a, const void *b)
 {
         struct refinfo *r1 = *(struct refinfo **)a;
         struct refinfo *r2 = *(struct refinfo **)b;
 
         return cmp_age(r1->tag->tagger_date, r2->tag->tagger_date);
 }
 
 static int print_branch(struct refinfo *ref)
 {
         struct commitinfo *info = ref->commit;
         char *name = (char *)ref->refname;
 
         if (!info)
                 return 1;
diff --git a/ui-repolist.c b/ui-repolist.c
index ad9b1bc..eeeaf3d 100644
--- a/ui-repolist.c
+++ b/ui-repolist.c
@@ -1,60 +1,61 @@
 /* ui-repolist.c: functions for generating the repolist page
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include <time.h>
 
 #include "cgit.h"
 #include "html.h"
+#include "ui-shared.h"
 
 time_t read_agefile(char *path)
 {
         FILE *f;
         static char buf[64], buf2[64];
 
         if (!(f = fopen(path, "r")))
                 return -1;
         fgets(buf, sizeof(buf), f);
         fclose(f);
         if (parse_date(buf, buf2, sizeof(buf2)))
                 return strtoul(buf2, NULL, 10);
         else
                 return 0;
 }
 
 static void print_modtime(struct cgit_repo *repo)
 {
         char *path;
         struct stat s;
 
         path = fmt("%s/%s", repo->path, ctx.cfg.agefile);
         if (stat(path, &s) == 0) {
                 cgit_print_age(read_agefile(path), -1, NULL);
                 return;
         }
 
         path = fmt("%s/refs/heads/%s", repo->path, repo->defbranch);
         if (stat(path, &s) != 0)
                 return;
         cgit_print_age(s.st_mtime, -1, NULL);
 }
 
 void cgit_print_repolist()
 {
         int i, columns = 4;
         char *last_group = NULL;
 
         if (ctx.cfg.enable_index_links)
                 columns++;
 
         ctx.page.title = ctx.cfg.root_title;
         cgit_print_http_headers(&ctx);
         cgit_print_docstart(&ctx);
         cgit_print_pageheader(&ctx);
 
         html("<table summary='repository list' class='list nowrap'>");
         if (ctx.cfg.index_header) {
diff --git a/ui-shared.h b/ui-shared.h
new file mode 100644
index 0000000..94de884
--- a/dev/null
+++ b/ui-shared.h
@@ -0,0 +1,36 @@
+#ifndef UI_SHARED_H
+#define UI_SHARED_H
+
+extern char *cgit_repourl(const char *reponame);
+extern char *cgit_fileurl(const char *reponame, const char *pagename,
+                          const char *filename, const char *query);
+extern char *cgit_pageurl(const char *reponame, const char *pagename,
+                          const char *query);
+
+extern void cgit_tree_link(char *name, char *title, char *class, char *head,
+                           char *rev, char *path);
+extern void cgit_log_link(char *name, char *title, char *class, char *head,
+                          char *rev, char *path, int ofs, char *grep,
+                          char *pattern);
+extern void cgit_commit_link(char *name, char *title, char *class, char *head,
+                             char *rev);
+extern void cgit_refs_link(char *name, char *title, char *class, char *head,
+                           char *rev, char *path);
+extern void cgit_snapshot_link(char *name, char *title, char *class,
+                               char *head, char *rev, char *archivename);
+extern void cgit_diff_link(char *name, char *title, char *class, char *head,
+                           char *new_rev, char *old_rev, char *path);
+extern void cgit_object_link(struct object *obj);
+
+extern void cgit_print_error(char *msg);
+extern void cgit_print_date(time_t secs, char *format);
+extern void cgit_print_age(time_t t, time_t max_relative, char *format);
+extern void cgit_print_http_headers(struct cgit_context *ctx);
+extern void cgit_print_docstart(struct cgit_context *ctx);
+extern void cgit_print_docend();
+extern void cgit_print_pageheader(struct cgit_context *ctx);
+extern void cgit_print_filemode(unsigned short mode);
+extern void cgit_print_snapshot_links(const char *repo, const char *head,
+                                      const char *hex, int snapshots);
+
+#endif /* UI_SHARED_H */
diff --git a/ui-snapshot.c b/ui-snapshot.c
index 512fcd2..966a140 100644
--- a/ui-snapshot.c
+++ b/ui-snapshot.c
@@ -1,58 +1,59 @@
 /* ui-snapshot.c: generate snapshot of a commit
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 #include "html.h"
+#include "ui-shared.h"
 
 static int write_compressed_tar_archive(struct archiver_args *args,const char *filter)
 {
         int rw[2];
         pid_t gzpid;
         int stdout2;
         int status;
         int rv;
 
         stdout2 = chk_non_negative(dup(STDIN_FILENO), "Preserving STDOUT before compressing");
         chk_zero(pipe(rw), "Opening pipe from compressor subprocess");
         gzpid = chk_non_negative(fork(), "Forking compressor subprocess");
         if(gzpid==0) {
                 /* child */
                 chk_zero(close(rw[1]), "Closing write end of pipe in child");
                 chk_zero(close(STDIN_FILENO), "Closing STDIN");
                 chk_non_negative(dup2(rw[0],STDIN_FILENO), "Redirecting compressor input to stdin");
                 execlp(filter,filter,NULL);
                 _exit(-1);
         }
         /* parent */
         chk_zero(close(rw[0]), "Closing read end of pipe");
         chk_non_negative(dup2(rw[1],STDOUT_FILENO), "Redirecting output to compressor");
 
         rv = write_tar_archive(args);
 
         chk_zero(close(STDOUT_FILENO), "Closing STDOUT redirected to compressor");
         chk_non_negative(dup2(stdout2,STDOUT_FILENO), "Restoring uncompressed STDOUT");
         chk_zero(close(stdout2), "Closing uncompressed STDOUT");
         chk_zero(close(rw[1]), "Closing write end of pipe in parent");
         chk_positive(waitpid(gzpid,&status,0), "Waiting on compressor process");
         if(! ( WIFEXITED(status) && WEXITSTATUS(status)==0 ) )
                 cgit_print_error("Failed to compress archive");
 
         return rv;
 }
 
 static int write_tar_gzip_archive(struct archiver_args *args)
 {
         return write_compressed_tar_archive(args,"gzip");
 }
 
 static int write_tar_bzip2_archive(struct archiver_args *args)
 {
         return write_compressed_tar_archive(args,"bzip2");
 }
 
 const struct cgit_snapshot_format cgit_snapshot_formats[] = {
diff --git a/ui-tag.c b/ui-tag.c
index 2998d02..ab2c66d 100644
--- a/ui-tag.c
+++ b/ui-tag.c
@@ -1,58 +1,59 @@
 /* ui-tag.c: display a tag
  *
  * Copyright (C) 2007 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 #include "html.h"
+#include "ui-shared.h"
 
 static void print_tag_content(char *buf)
 {
         char *p;
 
         if (!buf)
                 return;
 
         html("<div class='commit-subject'>");
         p = strchr(buf, '\n');
         if (p)
                 *p = '\0';
         html_txt(buf);
         html("</div>");
         if (p) {
                 html("<div class='commit-msg'>");
                 html_txt(++p);
                 html("</div>");
         }
 }
 
 void cgit_print_tag(char *revname)
 {
         unsigned char sha1[20];
         struct object *obj;
         struct tag *tag;
         struct taginfo *info;
 
         if (get_sha1(revname, sha1)) {
                 cgit_print_error(fmt("Bad tag reference: %s", revname));
                 return;
         }
         obj = parse_object(sha1);
         if (!obj) {
                 cgit_print_error(fmt("Bad object id: %s", sha1_to_hex(sha1)));
                 return;
         }
         if (obj->type == OBJ_TAG) {
                 tag = lookup_tag(sha1);
                 if (!tag || parse_tag(tag) || !(info = cgit_parse_tag(tag))) {
                         cgit_print_error(fmt("Bad tag object: %s", revname));
                         return;
                 }
                 html("<table class='commit-info'>\n");
                 htmlf("<tr><td>Tag name</td><td>%s (%s)</td></tr>\n",
                       revname, sha1_to_hex(sha1));
                 if (info->tagger_date > 0) {
                         html("<tr><td>Tag date</td><td>");
diff --git a/ui-tree.c b/ui-tree.c
index 7912784..9be3140 100644
--- a/ui-tree.c
+++ b/ui-tree.c
@@ -1,58 +1,59 @@
 /* ui-tree.c: functions for tree output
  *
  * Copyright (C) 2006 Lars Hjemli
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  */
 
 #include "cgit.h"
 #include "html.h"
+#include "ui-shared.h"
 
 char *curr_rev;
 char *match_path;
 int header = 0;
 
 static void print_object(const unsigned char *sha1, char *path)
 {
         enum object_type type;
         char *buf;
         unsigned long size, lineno, start, idx;
         const char *linefmt = "<tr><td class='no'><a id='n%1$d' name='n%1$d' href='#n%1$d'>%1$d</a></td><td class='txt'>";
 
         type = sha1_object_info(sha1, &size);
         if (type == OBJ_BAD) {
                 cgit_print_error(fmt("Bad object name: %s",
                                      sha1_to_hex(sha1)));
                 return;
         }
 
         buf = read_sha1_file(sha1, &type, &size);
         if (!buf) {
                 cgit_print_error(fmt("Error reading object %s",
                                      sha1_to_hex(sha1)));
                 return;
         }
 
         html(" blob: <a href='");
         html_attr(cgit_pageurl(ctx.qry.repo, "blob", fmt("id=%s", sha1_to_hex(sha1))));
         htmlf("'>%s</a>",sha1_to_hex(sha1));
 
         html("<table summary='blob content' class='blob'>\n");
         idx = 0;
         start = 0;
         lineno = 0;
         while(idx < size) {
                 if (buf[idx] == '\n') {
                         buf[idx] = '\0';
                         htmlf(linefmt, ++lineno);
                         html_txt(buf + start);
                         html("</td></tr>\n");
                         start = idx + 1;
                 }
                 idx++;
         }
         htmlf(linefmt, ++lineno);
         html_txt(buf + start);
         html("</td></tr>\n");
         html("</table>\n");