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");