Nov is the correct abbreviation

author: Danijel Tašov <dt@korn.shell.la> 2009-11-02 21:10:04 (UTC)
committer: Lars Hjemli <hjemli@gmail.com> 2009-11-07 14:29:54 (UTC)
commit: e34a3b5adc00255f8acb7d674e5fdadef2ac80f7 (patch) (unidiff)
tree: 801fc9c229bfbb84f4d49ac8c1ec6d423a7d3ef0
parent: 9735835c0e9f2c4a0caf5a431fc455d5855472aa (diff)
download: cgit-e34a3b5adc00255f8acb7d674e5fdadef2ac80f7.zip
cgit-e34a3b5adc00255f8acb7d674e5fdadef2ac80f7.tar.gz
cgit-e34a3b5adc00255f8acb7d674e5fdadef2ac80f7.tar.bz2
1 files changed, 1 insertions, 1 deletions
diff --git a/ui-shared.c b/ui-shared.c
index 07d5dd4..4049a2b 100644
--- a/ui-shared.c
+++ b/ui-shared.c
@@ -1,407 +1,407 @@
 /* ui-shared.c: common web output functions
 *
 * 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 "html.h"
 const char cgit_doctype[] =
 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
 "  \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
 static char *http_date(time_t t)
 {
        static char day[][4] =
                {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
        static char month[][4] =
                {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
-                 "Jul", "Aug", "Sep", "Oct", "Now", "Dec"};
+                 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
        struct tm *tm = gmtime(&t);
        return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday],
                   tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year,
                   tm->tm_hour, tm->tm_min, tm->tm_sec);
 }
 void cgit_print_error(char *msg)
 {
        html("<div class='error'>");
        html_txt(msg);
        html("</div>\n");
 }
 char *cgit_httpscheme()
 {
        if (ctx.env.https && !strcmp(ctx.env.https, "on"))
                return "https://";
        else
                return "http://";
 }
 char *cgit_hosturl()
 {
        if (ctx.env.http_host)
                return ctx.env.http_host;
        if (!ctx.env.server_name)
                return NULL;
        if (!ctx.env.server_port || atoi(ctx.env.server_port) == 80)
                return ctx.env.server_name;
        return xstrdup(fmt("%s:%s", ctx.env.server_name, ctx.env.server_port));
 }
 char *cgit_rooturl()
 {
        if (ctx.cfg.virtual_root)
                return fmt("%s/", ctx.cfg.virtual_root);
        else
                return ctx.cfg.script_name;
 }
 char *cgit_repourl(const char *reponame)
 {
        if (ctx.cfg.virtual_root) {
                return fmt("%s/%s/", ctx.cfg.virtual_root, reponame);
        } else {
                return fmt("?r=%s", reponame);
        }
 }
 char *cgit_fileurl(const char *reponame, const char *pagename,
                   const char *filename, const char *query)
 {
        char *tmp;
        char *delim;
        if (ctx.cfg.virtual_root) {
                tmp = fmt("%s/%s/%s/%s", ctx.cfg.virtual_root, reponame,
                          pagename, (filename ? filename:""));
                delim = "?";
        } else {
                tmp = fmt("?url=%s/%s/%s", reponame, pagename,
                          (filename ? filename : ""));
                delim = "&";
        }
        if (query)
                tmp = fmt("%s%s%s", tmp, delim, query);
        return tmp;
 }
 char *cgit_pageurl(const char *reponame, const char *pagename,
                   const char *query)
 {
        return cgit_fileurl(reponame,pagename,0,query);
 }
 const char *cgit_repobasename(const char *reponame)
 {
        /* I assume we don't need to store more than one repo basename */
        static char rvbuf[1024];
        int p;
        const char *rv;
        strncpy(rvbuf,reponame,sizeof(rvbuf));
        if(rvbuf[sizeof(rvbuf)-1])
                die("cgit_repobasename: truncated repository name '%s'", reponame);
        p = strlen(rvbuf)-1;
        /* strip trailing slashes */
        while(p && rvbuf[p]=='/') rvbuf[p--]=0;
        /* strip trailing .git */
        if(p>=3 && !strncmp(&rvbuf[p-3],".git",4)) {
                p -= 3; rvbuf[p--] = 0;
        }
        /* strip more trailing slashes if any */
        while( p && rvbuf[p]=='/') rvbuf[p--]=0;
        /* find last slash in the remaining string */
        rv = strrchr(rvbuf,'/');
        if(rv)
                return ++rv;
        return rvbuf;
 }
 char *cgit_currurl()
 {
        if (!ctx.cfg.virtual_root)
                return ctx.cfg.script_name;
        else if (ctx.qry.page)
                return fmt("%s/%s/%s/", ctx.cfg.virtual_root, ctx.qry.repo, ctx.qry.page);
        else if (ctx.qry.repo)
                return fmt("%s/%s/", ctx.cfg.virtual_root, ctx.qry.repo);
        else
                return fmt("%s/", ctx.cfg.virtual_root);
 }
 static void site_url(char *page, char *search, int ofs)
 {
        char *delim = "?";
        if (ctx.cfg.virtual_root) {
                html_attr(ctx.cfg.virtual_root);
                if (ctx.cfg.virtual_root[strlen(ctx.cfg.virtual_root) - 1] != '/')
                        html("/");
        } else
                html(ctx.cfg.script_name);
        if (page) {
                htmlf("?p=%s", page);
                delim = "&";
        }
        if (search) {
                html(delim);
                html("q=");
                html_attr(search);
                delim = "&";
        }
        if (ofs) {
                html(delim);
                htmlf("ofs=%d", ofs);
        }
 }
 static void site_link(char *page, char *name, char *title, char *class,
                      char *search, int ofs)
 {
        html("<a");
        if (title) {
                html(" title='");
                html_attr(title);
                html("'");
        }
        if (class) {
                html(" class='");
                html_attr(class);
                html("'");
        }
        html(" href='");
        site_url(page, search, ofs);
        html("'>");
        html_txt(name);
        html("</a>");
 }
 void cgit_index_link(char *name, char *title, char *class, char *pattern,
                     int ofs)
 {
        site_link(NULL, name, title, class, pattern, ofs);
 }
 static char *repolink(char *title, char *class, char *page, char *head,
                      char *path)
 {
        char *delim = "?";
        html("<a");
        if (title) {
                html(" title='");
                html_attr(title);
                html("'");
        }
        if (class) {
                html(" class='");
                html_attr(class);
                html("'");
        }
        html(" href='");
        if (ctx.cfg.virtual_root) {
                html_url_path(ctx.cfg.virtual_root);
                if (ctx.cfg.virtual_root[strlen(ctx.cfg.virtual_root) - 1] != '/')
                        html("/");
                html_url_path(ctx.repo->url);
                if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/')
                        html("/");
                if (page) {
                        html_url_path(page);
                        html("/");
                        if (path)
                                html_url_path(path);
                }
        } else {
                html(ctx.cfg.script_name);
                html("?url=");
                html_url_arg(ctx.repo->url);
                if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/')
                        html("/");
                if (page) {
                        html_url_arg(page);
                        html("/");
                        if (path)
                                html_url_arg(path);
                }
                delim = "&amp;";
        }
        if (head && strcmp(head, ctx.repo->defbranch)) {
                html(delim);
                html("h=");
                html_url_arg(head);
                delim = "&amp;";
        }
        return fmt("%s", delim);
 }
 static void reporevlink(char *page, char *name, char *title, char *class,
                        char *head, char *rev, char *path)
 {
        char *delim;
        delim = repolink(title, class, page, head, path);
        if (rev && strcmp(rev, ctx.qry.head)) {
                html(delim);
                html("id=");
                html_url_arg(rev);
        }
        html("'>");
        html_txt(name);
        html("</a>");
 }
 void cgit_summary_link(char *name, char *title, char *class, char *head)
 {
        reporevlink(NULL, name, title, class, head, NULL, NULL);
 }
 void cgit_tag_link(char *name, char *title, char *class, char *head,
                   char *rev)
 {
        reporevlink("tag", name, title, class, head, rev, NULL);
 }
 void cgit_tree_link(char *name, char *title, char *class, char *head,
                    char *rev, char *path)
 {
        reporevlink("tree", name, title, class, head, rev, path);
 }
 void cgit_plain_link(char *name, char *title, char *class, char *head,
                     char *rev, char *path)
 {
        reporevlink("plain", name, title, class, head, rev, path);
 }
 void cgit_log_link(char *name, char *title, char *class, char *head,
                   char *rev, char *path, int ofs, char *grep, char *pattern,
                   int showmsg)
 {
        char *delim;
        delim = repolink(title, class, "log", head, path);
        if (rev && strcmp(rev, ctx.qry.head)) {
                html(delim);
                html("id=");
                html_url_arg(rev);
                delim = "&";
        }
        if (grep && pattern) {
                html(delim);
                html("qt=");
                html_url_arg(grep);
                delim = "&";
                html(delim);
                html("q=");
                html_url_arg(pattern);
        }
        if (ofs > 0) {
                html(delim);
                html("ofs=");
                htmlf("%d", ofs);
                delim = "&";
        }
        if (showmsg) {
                html(delim);
                html("showmsg=1");
        }
        html("'>");
        html_txt(name);
        html("</a>");
 }
 void cgit_commit_link(char *name, char *title, char *class, char *head,
                      char *rev)
 {
        if (strlen(name) > ctx.cfg.max_msg_len && ctx.cfg.max_msg_len >= 15) {
                name[ctx.cfg.max_msg_len] = '\0';
                name[ctx.cfg.max_msg_len - 1] = '.';
                name[ctx.cfg.max_msg_len - 2] = '.';
                name[ctx.cfg.max_msg_len - 3] = '.';
        }
        reporevlink("commit", name, title, class, head, rev, NULL);
 }
 void cgit_refs_link(char *name, char *title, char *class, char *head,
                    char *rev, char *path)
 {
        reporevlink("refs", name, title, class, head, rev, path);
 }
 void cgit_snapshot_link(char *name, char *title, char *class, char *head,
                        char *rev, char *archivename)
 {
        reporevlink("snapshot", name, title, class, head, rev, archivename);
 }
 void cgit_diff_link(char *name, char *title, char *class, char *head,
                    char *new_rev, char *old_rev, char *path)
 {
        char *delim;
        delim = repolink(title, class, "diff", head, path);
        if (new_rev && strcmp(new_rev, ctx.qry.head)) {
                html(delim);
                html("id=");
                html_url_arg(new_rev);
                delim = "&amp;";
        }
        if (old_rev) {
                html(delim);
                html("id2=");
                html_url_arg(old_rev);
        }
        html("'>");
        html_txt(name);
        html("</a>");
 }
 void cgit_patch_link(char *name, char *title, char *class, char *head,
                     char *rev)
 {
        reporevlink("patch", name, title, class, head, rev, NULL);
 }
 void cgit_stats_link(char *name, char *title, char *class, char *head,
                     char *path)
 {
        reporevlink("stats", name, title, class, head, NULL, path);
 }
 void cgit_object_link(struct object *obj)
 {
        char *page, *shortrev, *fullrev, *name;
        fullrev = sha1_to_hex(obj->sha1);
        shortrev = xstrdup(fullrev);
        shortrev[10] = '\0';
        if (obj->type == OBJ_COMMIT) {
                cgit_commit_link(fmt("commit %s...", shortrev), NULL, NULL,
                                 ctx.qry.head, fullrev);
                return;
        } else if (obj->type == OBJ_TREE)
                page = "tree";
        else if (obj->type == OBJ_TAG)
                page = "tag";
        else
                page = "blob";
        name = fmt("%s %s...", typename(obj->type), shortrev);
        reporevlink(page, name, NULL, NULL, ctx.qry.head, fullrev, NULL);
 }
 void cgit_print_date(time_t secs, char *format, int local_time)
 {
        char buf[64];
        struct tm *time;
        if (!secs)
                return;
        if(local_time)
                time = localtime(&secs);
        else
author	Danijel Tašov <dt@korn.shell.la>	2009-11-02 21:10:04 (UTC)
committer	Lars Hjemli <hjemli@gmail.com>	2009-11-07 14:29:54 (UTC)
commit	e34a3b5adc00255f8acb7d674e5fdadef2ac80f7 (patch) (unidiff)
tree	801fc9c229bfbb84f4d49ac8c1ec6d423a7d3ef0
parent	9735835c0e9f2c4a0caf5a431fc455d5855472aa (diff)
download	cgit-e34a3b5adc00255f8acb7d674e5fdadef2ac80f7.zip cgit-e34a3b5adc00255f8acb7d674e5fdadef2ac80f7.tar.gz cgit-e34a3b5adc00255f8acb7d674e5fdadef2ac80f7.tar.bz2

diff --git a/ui-shared.c b/ui-shared.c index 07d5dd4..4049a2b 100644 --- a/ui-shared.c +++ b/ui-shared.c
@@ -1,407 +1,407 @@
1	/* ui-shared.c: common web output functions	1	/* ui-shared.c: common web output functions
2	*	2	*
3	* Copyright (C) 2006 Lars Hjemli	3	* Copyright (C) 2006 Lars Hjemli
4	*	4	*
5	* Licensed under GNU General Public License v2	5	* Licensed under GNU General Public License v2
6	* (see COPYING for full license text)	6	* (see COPYING for full license text)
7	*/	7	*/
8		8
9	#include "cgit.h"	9	#include "cgit.h"
10	#include "cmd.h"	10	#include "cmd.h"
11	#include "html.h"	11	#include "html.h"
12		12
13	const char cgit_doctype[] =	13	const char cgit_doctype[] =
14	"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"	14	"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n"
15	" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";	15	" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
16		16
17	static char *http_date(time_t t)	17	static char *http_date(time_t t)
18	{	18	{
19	static char day[][4] =	19	static char day[][4] =
20	{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};	20	{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
21	static char month[][4] =	21	static char month[][4] =
22	{"Jan", "Feb", "Mar", "Apr", "May", "Jun",	22	{"Jan", "Feb", "Mar", "Apr", "May", "Jun",
23	"Jul", "Aug", "Sep", "Oct", "Now", "Dec"};	23	"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
24	struct tm *tm = gmtime(&t);	24	struct tm *tm = gmtime(&t);
25	return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday],	25	return fmt("%s, %02d %s %04d %02d:%02d:%02d GMT", day[tm->tm_wday],
26	tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year,	26	tm->tm_mday, month[tm->tm_mon], 1900+tm->tm_year,
27	tm->tm_hour, tm->tm_min, tm->tm_sec);	27	tm->tm_hour, tm->tm_min, tm->tm_sec);
28	}	28	}
29		29
30	void cgit_print_error(char *msg)	30	void cgit_print_error(char *msg)
31	{	31	{
32	html("<div class='error'>");	32	html("<div class='error'>");
33	html_txt(msg);	33	html_txt(msg);
34	html("</div>\n");	34	html("</div>\n");
35	}	35	}
36		36
37	char *cgit_httpscheme()	37	char *cgit_httpscheme()
38	{	38	{
39	if (ctx.env.https && !strcmp(ctx.env.https, "on"))	39	if (ctx.env.https && !strcmp(ctx.env.https, "on"))
40	return "https://";	40	return "https://";
41	else	41	else
42	return "http://";	42	return "http://";
43	}	43	}
44		44
45	char *cgit_hosturl()	45	char *cgit_hosturl()
46	{	46	{
47	if (ctx.env.http_host)	47	if (ctx.env.http_host)
48	return ctx.env.http_host;	48	return ctx.env.http_host;
49	if (!ctx.env.server_name)	49	if (!ctx.env.server_name)
50	return NULL;	50	return NULL;
51	if (!ctx.env.server_port \|\| atoi(ctx.env.server_port) == 80)	51	if (!ctx.env.server_port \|\| atoi(ctx.env.server_port) == 80)
52	return ctx.env.server_name;	52	return ctx.env.server_name;
53	return xstrdup(fmt("%s:%s", ctx.env.server_name, ctx.env.server_port));	53	return xstrdup(fmt("%s:%s", ctx.env.server_name, ctx.env.server_port));
54	}	54	}
55		55
56	char *cgit_rooturl()	56	char *cgit_rooturl()
57	{	57	{
58	if (ctx.cfg.virtual_root)	58	if (ctx.cfg.virtual_root)
59	return fmt("%s/", ctx.cfg.virtual_root);	59	return fmt("%s/", ctx.cfg.virtual_root);
60	else	60	else
61	return ctx.cfg.script_name;	61	return ctx.cfg.script_name;
62	}	62	}
63		63
64	char cgit_repourl(const char reponame)	64	char cgit_repourl(const char reponame)
65	{	65	{
66	if (ctx.cfg.virtual_root) {	66	if (ctx.cfg.virtual_root) {
67	return fmt("%s/%s/", ctx.cfg.virtual_root, reponame);	67	return fmt("%s/%s/", ctx.cfg.virtual_root, reponame);
68	} else {	68	} else {
69	return fmt("?r=%s", reponame);	69	return fmt("?r=%s", reponame);
70	}	70	}
71	}	71	}
72		72
73	char cgit_fileurl(const char reponame, const char *pagename,	73	char cgit_fileurl(const char reponame, const char *pagename,
74	const char filename, const char query)	74	const char filename, const char query)
75	{	75	{
76	char *tmp;	76	char *tmp;
77	char *delim;	77	char *delim;
78		78
79	if (ctx.cfg.virtual_root) {	79	if (ctx.cfg.virtual_root) {
80	tmp = fmt("%s/%s/%s/%s", ctx.cfg.virtual_root, reponame,	80	tmp = fmt("%s/%s/%s/%s", ctx.cfg.virtual_root, reponame,
81	pagename, (filename ? filename:""));	81	pagename, (filename ? filename:""));
82	delim = "?";	82	delim = "?";
83	} else {	83	} else {
84	tmp = fmt("?url=%s/%s/%s", reponame, pagename,	84	tmp = fmt("?url=%s/%s/%s", reponame, pagename,
85	(filename ? filename : ""));	85	(filename ? filename : ""));
86	delim = "&";	86	delim = "&";
87	}	87	}
88	if (query)	88	if (query)
89	tmp = fmt("%s%s%s", tmp, delim, query);	89	tmp = fmt("%s%s%s", tmp, delim, query);
90	return tmp;	90	return tmp;
91	}	91	}
92		92
93	char cgit_pageurl(const char reponame, const char *pagename,	93	char cgit_pageurl(const char reponame, const char *pagename,
94	const char *query)	94	const char *query)
95	{	95	{
96	return cgit_fileurl(reponame,pagename,0,query);	96	return cgit_fileurl(reponame,pagename,0,query);
97	}	97	}
98		98
99	const char cgit_repobasename(const char reponame)	99	const char cgit_repobasename(const char reponame)
100	{	100	{
101	/* I assume we don't need to store more than one repo basename */	101	/* I assume we don't need to store more than one repo basename */
102	static char rvbuf[1024];	102	static char rvbuf[1024];
103	int p;	103	int p;
104	const char *rv;	104	const char *rv;
105	strncpy(rvbuf,reponame,sizeof(rvbuf));	105	strncpy(rvbuf,reponame,sizeof(rvbuf));
106	if(rvbuf[sizeof(rvbuf)-1])	106	if(rvbuf[sizeof(rvbuf)-1])
107	die("cgit_repobasename: truncated repository name '%s'", reponame);	107	die("cgit_repobasename: truncated repository name '%s'", reponame);
108	p = strlen(rvbuf)-1;	108	p = strlen(rvbuf)-1;
109	/* strip trailing slashes */	109	/* strip trailing slashes */
110	while(p && rvbuf[p]=='/') rvbuf[p--]=0;	110	while(p && rvbuf[p]=='/') rvbuf[p--]=0;
111	/* strip trailing .git */	111	/* strip trailing .git */
112	if(p>=3 && !strncmp(&rvbuf[p-3],".git",4)) {	112	if(p>=3 && !strncmp(&rvbuf[p-3],".git",4)) {
113	p -= 3; rvbuf[p--] = 0;	113	p -= 3; rvbuf[p--] = 0;
114	}	114	}
115	/* strip more trailing slashes if any */	115	/* strip more trailing slashes if any */
116	while( p && rvbuf[p]=='/') rvbuf[p--]=0;	116	while( p && rvbuf[p]=='/') rvbuf[p--]=0;
117	/* find last slash in the remaining string */	117	/* find last slash in the remaining string */
118	rv = strrchr(rvbuf,'/');	118	rv = strrchr(rvbuf,'/');
119	if(rv)	119	if(rv)
120	return ++rv;	120	return ++rv;
121	return rvbuf;	121	return rvbuf;
122	}	122	}
123		123
124	char *cgit_currurl()	124	char *cgit_currurl()
125	{	125	{
126	if (!ctx.cfg.virtual_root)	126	if (!ctx.cfg.virtual_root)
127	return ctx.cfg.script_name;	127	return ctx.cfg.script_name;
128	else if (ctx.qry.page)	128	else if (ctx.qry.page)
129	return fmt("%s/%s/%s/", ctx.cfg.virtual_root, ctx.qry.repo, ctx.qry.page);	129	return fmt("%s/%s/%s/", ctx.cfg.virtual_root, ctx.qry.repo, ctx.qry.page);
130	else if (ctx.qry.repo)	130	else if (ctx.qry.repo)
131	return fmt("%s/%s/", ctx.cfg.virtual_root, ctx.qry.repo);	131	return fmt("%s/%s/", ctx.cfg.virtual_root, ctx.qry.repo);
132	else	132	else
133	return fmt("%s/", ctx.cfg.virtual_root);	133	return fmt("%s/", ctx.cfg.virtual_root);
134	}	134	}
135		135
136	static void site_url(char page, char search, int ofs)	136	static void site_url(char page, char search, int ofs)
137	{	137	{
138	char *delim = "?";	138	char *delim = "?";
139		139
140	if (ctx.cfg.virtual_root) {	140	if (ctx.cfg.virtual_root) {
141	html_attr(ctx.cfg.virtual_root);	141	html_attr(ctx.cfg.virtual_root);
142	if (ctx.cfg.virtual_root[strlen(ctx.cfg.virtual_root) - 1] != '/')	142	if (ctx.cfg.virtual_root[strlen(ctx.cfg.virtual_root) - 1] != '/')
143	html("/");	143	html("/");
144	} else	144	} else
145	html(ctx.cfg.script_name);	145	html(ctx.cfg.script_name);
146		146
147	if (page) {	147	if (page) {
148	htmlf("?p=%s", page);	148	htmlf("?p=%s", page);
149	delim = "&";	149	delim = "&";
150	}	150	}
151	if (search) {	151	if (search) {
152	html(delim);	152	html(delim);
153	html("q=");	153	html("q=");
154	html_attr(search);	154	html_attr(search);
155	delim = "&";	155	delim = "&";
156	}	156	}
157	if (ofs) {	157	if (ofs) {
158	html(delim);	158	html(delim);
159	htmlf("ofs=%d", ofs);	159	htmlf("ofs=%d", ofs);
160	}	160	}
161	}	161	}
162		162
163	static void site_link(char page, char name, char title, char class,	163	static void site_link(char page, char name, char title, char class,
164	char *search, int ofs)	164	char *search, int ofs)
165	{	165	{
166	html("<a");	166	html("<a");
167	if (title) {	167	if (title) {
168	html(" title='");	168	html(" title='");
169	html_attr(title);	169	html_attr(title);
170	html("'");	170	html("'");
171	}	171	}
172	if (class) {	172	if (class) {
173	html(" class='");	173	html(" class='");
174	html_attr(class);	174	html_attr(class);
175	html("'");	175	html("'");
176	}	176	}
177	html(" href='");	177	html(" href='");
178	site_url(page, search, ofs);	178	site_url(page, search, ofs);
179	html("'>");	179	html("'>");
180	html_txt(name);	180	html_txt(name);
181	html("</a>");	181	html("</a>");
182	}	182	}
183		183
184	void cgit_index_link(char name, char title, char class, char pattern,	184	void cgit_index_link(char name, char title, char class, char pattern,
185	int ofs)	185	int ofs)
186	{	186	{
187	site_link(NULL, name, title, class, pattern, ofs);	187	site_link(NULL, name, title, class, pattern, ofs);
188	}	188	}
189		189
190	static char repolink(char title, char class, char page, char *head,	190	static char repolink(char title, char class, char page, char *head,
191	char *path)	191	char *path)
192	{	192	{
193	char *delim = "?";	193	char *delim = "?";
194		194
195	html("<a");	195	html("<a");
196	if (title) {	196	if (title) {
197	html(" title='");	197	html(" title='");
198	html_attr(title);	198	html_attr(title);
199	html("'");	199	html("'");
200	}	200	}
201	if (class) {	201	if (class) {
202	html(" class='");	202	html(" class='");
203	html_attr(class);	203	html_attr(class);
204	html("'");	204	html("'");
205	}	205	}
206	html(" href='");	206	html(" href='");
207	if (ctx.cfg.virtual_root) {	207	if (ctx.cfg.virtual_root) {
208	html_url_path(ctx.cfg.virtual_root);	208	html_url_path(ctx.cfg.virtual_root);
209	if (ctx.cfg.virtual_root[strlen(ctx.cfg.virtual_root) - 1] != '/')	209	if (ctx.cfg.virtual_root[strlen(ctx.cfg.virtual_root) - 1] != '/')
210	html("/");	210	html("/");
211	html_url_path(ctx.repo->url);	211	html_url_path(ctx.repo->url);
212	if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/')	212	if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/')
213	html("/");	213	html("/");
214	if (page) {	214	if (page) {
215	html_url_path(page);	215	html_url_path(page);
216	html("/");	216	html("/");
217	if (path)	217	if (path)
218	html_url_path(path);	218	html_url_path(path);
219	}	219	}
220	} else {	220	} else {
221	html(ctx.cfg.script_name);	221	html(ctx.cfg.script_name);
222	html("?url=");	222	html("?url=");
223	html_url_arg(ctx.repo->url);	223	html_url_arg(ctx.repo->url);
224	if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/')	224	if (ctx.repo->url[strlen(ctx.repo->url) - 1] != '/')
225	html("/");	225	html("/");
226	if (page) {	226	if (page) {
227	html_url_arg(page);	227	html_url_arg(page);
228	html("/");	228	html("/");
229	if (path)	229	if (path)
230	html_url_arg(path);	230	html_url_arg(path);
231	}	231	}
232	delim = "&";	232	delim = "&";
233	}	233	}
234	if (head && strcmp(head, ctx.repo->defbranch)) {	234	if (head && strcmp(head, ctx.repo->defbranch)) {
235	html(delim);	235	html(delim);
236	html("h=");	236	html("h=");
237	html_url_arg(head);	237	html_url_arg(head);
238	delim = "&";	238	delim = "&";
239	}	239	}
240	return fmt("%s", delim);	240	return fmt("%s", delim);
241	}	241	}
242		242
243	static void reporevlink(char page, char name, char title, char class,	243	static void reporevlink(char page, char name, char title, char class,
244	char head, char rev, char *path)	244	char head, char rev, char *path)
245	{	245	{
246	char *delim;	246	char *delim;
247		247
248	delim = repolink(title, class, page, head, path);	248	delim = repolink(title, class, page, head, path);
249	if (rev && strcmp(rev, ctx.qry.head)) {	249	if (rev && strcmp(rev, ctx.qry.head)) {
250	html(delim);	250	html(delim);
251	html("id=");	251	html("id=");
252	html_url_arg(rev);	252	html_url_arg(rev);
253	}	253	}
254	html("'>");	254	html("'>");
255	html_txt(name);	255	html_txt(name);
256	html("</a>");	256	html("</a>");
257	}	257	}
258		258
259	void cgit_summary_link(char name, char title, char class, char head)	259	void cgit_summary_link(char name, char title, char class, char head)
260	{	260	{
261	reporevlink(NULL, name, title, class, head, NULL, NULL);	261	reporevlink(NULL, name, title, class, head, NULL, NULL);
262	}	262	}
263		263
264	void cgit_tag_link(char name, char title, char class, char head,	264	void cgit_tag_link(char name, char title, char class, char head,
265	char *rev)	265	char *rev)
266	{	266	{
267	reporevlink("tag", name, title, class, head, rev, NULL);	267	reporevlink("tag", name, title, class, head, rev, NULL);
268	}	268	}
269		269
270	void cgit_tree_link(char name, char title, char class, char head,	270	void cgit_tree_link(char name, char title, char class, char head,
271	char rev, char path)	271	char rev, char path)
272	{	272	{
273	reporevlink("tree", name, title, class, head, rev, path);	273	reporevlink("tree", name, title, class, head, rev, path);
274	}	274	}
275		275
276	void cgit_plain_link(char name, char title, char class, char head,	276	void cgit_plain_link(char name, char title, char class, char head,
277	char rev, char path)	277	char rev, char path)
278	{	278	{
279	reporevlink("plain", name, title, class, head, rev, path);	279	reporevlink("plain", name, title, class, head, rev, path);
280	}	280	}
281		281
282	void cgit_log_link(char name, char title, char class, char head,	282	void cgit_log_link(char name, char title, char class, char head,
283	char rev, char path, int ofs, char grep, char pattern,	283	char rev, char path, int ofs, char grep, char pattern,
284	int showmsg)	284	int showmsg)
285	{	285	{
286	char *delim;	286	char *delim;
287		287
288	delim = repolink(title, class, "log", head, path);	288	delim = repolink(title, class, "log", head, path);
289	if (rev && strcmp(rev, ctx.qry.head)) {	289	if (rev && strcmp(rev, ctx.qry.head)) {
290	html(delim);	290	html(delim);
291	html("id=");	291	html("id=");
292	html_url_arg(rev);	292	html_url_arg(rev);
293	delim = "&";	293	delim = "&";
294	}	294	}
295	if (grep && pattern) {	295	if (grep && pattern) {
296	html(delim);	296	html(delim);
297	html("qt=");	297	html("qt=");
298	html_url_arg(grep);	298	html_url_arg(grep);
299	delim = "&";	299	delim = "&";
300	html(delim);	300	html(delim);
301	html("q=");	301	html("q=");
302	html_url_arg(pattern);	302	html_url_arg(pattern);
303	}	303	}
304	if (ofs > 0) {	304	if (ofs > 0) {
305	html(delim);	305	html(delim);
306	html("ofs=");	306	html("ofs=");
307	htmlf("%d", ofs);	307	htmlf("%d", ofs);
308	delim = "&";	308	delim = "&";
309	}	309	}
310	if (showmsg) {	310	if (showmsg) {
311	html(delim);	311	html(delim);
312	html("showmsg=1");	312	html("showmsg=1");
313	}	313	}
314	html("'>");	314	html("'>");
315	html_txt(name);	315	html_txt(name);
316	html("</a>");	316	html("</a>");
317	}	317	}
318		318
319	void cgit_commit_link(char name, char title, char class, char head,	319	void cgit_commit_link(char name, char title, char class, char head,
320	char *rev)	320	char *rev)
321	{	321	{
322	if (strlen(name) > ctx.cfg.max_msg_len && ctx.cfg.max_msg_len >= 15) {	322	if (strlen(name) > ctx.cfg.max_msg_len && ctx.cfg.max_msg_len >= 15) {
323	name[ctx.cfg.max_msg_len] = '\0';	323	name[ctx.cfg.max_msg_len] = '\0';
324	name[ctx.cfg.max_msg_len - 1] = '.';	324	name[ctx.cfg.max_msg_len - 1] = '.';
325	name[ctx.cfg.max_msg_len - 2] = '.';	325	name[ctx.cfg.max_msg_len - 2] = '.';
326	name[ctx.cfg.max_msg_len - 3] = '.';	326	name[ctx.cfg.max_msg_len - 3] = '.';
327	}	327	}
328	reporevlink("commit", name, title, class, head, rev, NULL);	328	reporevlink("commit", name, title, class, head, rev, NULL);
329	}	329	}
330		330
331	void cgit_refs_link(char name, char title, char class, char head,	331	void cgit_refs_link(char name, char title, char class, char head,
332	char rev, char path)	332	char rev, char path)
333	{	333	{
334	reporevlink("refs", name, title, class, head, rev, path);	334	reporevlink("refs", name, title, class, head, rev, path);
335	}	335	}
336		336
337	void cgit_snapshot_link(char name, char title, char class, char head,	337	void cgit_snapshot_link(char name, char title, char class, char head,
338	char rev, char archivename)	338	char rev, char archivename)
339	{	339	{
340	reporevlink("snapshot", name, title, class, head, rev, archivename);	340	reporevlink("snapshot", name, title, class, head, rev, archivename);
341	}	341	}
342		342
343	void cgit_diff_link(char name, char title, char class, char head,	343	void cgit_diff_link(char name, char title, char class, char head,
344	char new_rev, char old_rev, char *path)	344	char new_rev, char old_rev, char *path)
345	{	345	{
346	char *delim;	346	char *delim;
347		347
348	delim = repolink(title, class, "diff", head, path);	348	delim = repolink(title, class, "diff", head, path);
349	if (new_rev && strcmp(new_rev, ctx.qry.head)) {	349	if (new_rev && strcmp(new_rev, ctx.qry.head)) {
350	html(delim);	350	html(delim);
351	html("id=");	351	html("id=");
352	html_url_arg(new_rev);	352	html_url_arg(new_rev);
353	delim = "&";	353	delim = "&";
354	}	354	}
355	if (old_rev) {	355	if (old_rev) {
356	html(delim);	356	html(delim);
357	html("id2=");	357	html("id2=");
358	html_url_arg(old_rev);	358	html_url_arg(old_rev);
359	}	359	}
360	html("'>");	360	html("'>");
361	html_txt(name);	361	html_txt(name);
362	html("</a>");	362	html("</a>");
363	}	363	}
364		364
365	void cgit_patch_link(char name, char title, char class, char head,	365	void cgit_patch_link(char name, char title, char class, char head,
366	char *rev)	366	char *rev)
367	{	367	{
368	reporevlink("patch", name, title, class, head, rev, NULL);	368	reporevlink("patch", name, title, class, head, rev, NULL);
369	}	369	}
370		370
371	void cgit_stats_link(char name, char title, char class, char head,	371	void cgit_stats_link(char name, char title, char class, char head,
372	char *path)	372	char *path)
373	{	373	{
374	reporevlink("stats", name, title, class, head, NULL, path);	374	reporevlink("stats", name, title, class, head, NULL, path);
375	}	375	}
376		376
377	void cgit_object_link(struct object *obj)	377	void cgit_object_link(struct object *obj)
378	{	378	{
379	char page, shortrev, fullrev, name;	379	char page, shortrev, fullrev, name;
380		380
381	fullrev = sha1_to_hex(obj->sha1);	381	fullrev = sha1_to_hex(obj->sha1);
382	shortrev = xstrdup(fullrev);	382	shortrev = xstrdup(fullrev);
383	shortrev[10] = '\0';	383	shortrev[10] = '\0';
384	if (obj->type == OBJ_COMMIT) {	384	if (obj->type == OBJ_COMMIT) {
385	cgit_commit_link(fmt("commit %s...", shortrev), NULL, NULL,	385	cgit_commit_link(fmt("commit %s...", shortrev), NULL, NULL,
386	ctx.qry.head, fullrev);	386	ctx.qry.head, fullrev);
387	return;	387	return;
388	} else if (obj->type == OBJ_TREE)	388	} else if (obj->type == OBJ_TREE)
389	page = "tree";	389	page = "tree";
390	else if (obj->type == OBJ_TAG)	390	else if (obj->type == OBJ_TAG)
391	page = "tag";	391	page = "tag";
392	else	392	else
393	page = "blob";	393	page = "blob";
394	name = fmt("%s %s...", typename(obj->type), shortrev);	394	name = fmt("%s %s...", typename(obj->type), shortrev);
395	reporevlink(page, name, NULL, NULL, ctx.qry.head, fullrev, NULL);	395	reporevlink(page, name, NULL, NULL, ctx.qry.head, fullrev, NULL);
396	}	396	}
397		397
398	void cgit_print_date(time_t secs, char *format, int local_time)	398	void cgit_print_date(time_t secs, char *format, int local_time)
399	{	399	{
400	char buf[64];	400	char buf[64];
401	struct tm *time;	401	struct tm *time;
402		402
403	if (!secs)	403	if (!secs)
404	return;	404	return;
405	if(local_time)	405	if(local_time)
406	time = localtime(&secs);	406	time = localtime(&secs);
407	else	407	else