6 files changed, 25 insertions, 12 deletions

diff --git a/Makefile b/Makefile
index 2a15469..6c9d118 100644
--- a/Makefile
+++ b/Makefile
@@ -1,183 +1,191 @@
 CGIT_VERSION = v0.8.3.3
 CGIT_SCRIPT_NAME = cgit.cgi
 CGIT_SCRIPT_PATH = /var/www/htdocs/cgit
 CGIT_DATA_PATH = $(CGIT_SCRIPT_PATH)
 CGIT_CONFIG = /etc/cgitrc
 CACHE_ROOT = /var/cache/cgit
 SHA1_HEADER = <openssl/sha.h>
 GIT_VER = 1.7.2.2
 GIT_URL = http://www.kernel.org/pub/software/scm/git/git-$(GIT_VER).tar.bz2
 INSTALL = install
 
 # Define NO_STRCASESTR if you don't have strcasestr.
 #
 # Define NO_OPENSSL to disable linking with OpenSSL and use bundled SHA1
 # implementation (slower).
 #
 # Define NEEDS_LIBICONV if linking with libc is not enough (eg. Darwin).
 #
+# Define NO_C99_FORMAT if your formatted IO functions (printf/scanf et.al.)
+# do not support the 'size specifiers' introduced by C99, namely ll, hh,
+# j, z, t. (representing long long int, char, intmax_t, size_t, ptrdiff_t).
+# some C compilers supported these specifiers prior to C99 as an extension.
+#
 
 #-include config.mak
 
 #
 # Platform specific tweaks
 #
 
 uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
 uname_O := $(shell sh -c 'uname -o 2>/dev/null || echo not')
 uname_R := $(shell sh -c 'uname -r 2>/dev/null || echo not')
 
 ifeq ($(uname_O),Cygwin)
         NO_STRCASESTR = YesPlease
         NEEDS_LIBICONV = YesPlease
 endif
 
 #
 # Let the user override the above settings.
 #
 -include cgit.conf
 
 #
 # Define a way to invoke make in subdirs quietly, shamelessly ripped
 # from git.git
 #
 QUIET_SUBDIR0  = +$(MAKE) -C # space to separate -C and subdir
 QUIET_SUBDIR1  =
 
 ifneq ($(findstring $(MAKEFLAGS),w),w)
 PRINT_DIR = --no-print-directory
 else # "make -w"
 NO_SUBDIR = :
 endif
 
 ifndef V
         QUIET_CC       = @echo '   ' CC $@;
         QUIET_MM       = @echo '   ' MM $@;
         QUIET_SUBDIR0  = +@subdir=
         QUIET_SUBDIR1  = ;$(NO_SUBDIR) echo '   ' SUBDIR $$subdir; \
                          $(MAKE) $(PRINT_DIR) -C $$subdir
 endif
 
 #
 # Define a pattern rule for automatic dependency building
 #
 %.d: %.c
         $(QUIET_MM)$(CC) $(CFLAGS) -MM $< | sed -e 's/\($*\)\.o:/\1.o $@:/g' >$@
 
 #
 # Define a pattern rule for silent object building
 #
 %.o: %.c
         $(QUIET_CC)$(CC) -o $*.o -c $(CFLAGS) $<
 
 
 EXTLIBS = git/libgit.a git/xdiff/lib.a -lz -lpthread
 OBJECTS =
 OBJECTS += cache.o
 OBJECTS += cgit.o
 OBJECTS += cmd.o
 OBJECTS += configfile.o
 OBJECTS += html.o
 OBJECTS += parsing.o
 OBJECTS += scan-tree.o
 OBJECTS += shared.o
 OBJECTS += ui-atom.o
 OBJECTS += ui-blob.o
 OBJECTS += ui-clone.o
 OBJECTS += ui-commit.o
 OBJECTS += ui-diff.o
 OBJECTS += ui-log.o
 OBJECTS += ui-patch.o
 OBJECTS += ui-plain.o
 OBJECTS += ui-refs.o
 OBJECTS += ui-repolist.o
 OBJECTS += ui-shared.o
 OBJECTS += ui-snapshot.o
 OBJECTS += ui-ssdiff.o
 OBJECTS += ui-stats.o
 OBJECTS += ui-summary.o
 OBJECTS += ui-tag.o
 OBJECTS += ui-tree.o
 
 ifdef NEEDS_LIBICONV
         EXTLIBS += -liconv
 endif
 
 
 .PHONY: all libgit test install uninstall clean force-version get-git \
         doc man-doc html-doc clean-doc
 
 all: cgit
 
 VERSION: force-version
         @./gen-version.sh "$(CGIT_VERSION)"
 -include VERSION
 
 
 CFLAGS += -g -Wall -Igit
 CFLAGS += -DSHA1_HEADER='$(SHA1_HEADER)'
 CFLAGS += -DCGIT_VERSION='"$(CGIT_VERSION)"'
 CFLAGS += -DCGIT_CONFIG='"$(CGIT_CONFIG)"'
 CFLAGS += -DCGIT_SCRIPT_NAME='"$(CGIT_SCRIPT_NAME)"'
 CFLAGS += -DCGIT_CACHE_ROOT='"$(CACHE_ROOT)"'
 
 ifdef NO_ICONV
         CFLAGS += -DNO_ICONV
 endif
 ifdef NO_STRCASESTR
         CFLAGS += -DNO_STRCASESTR
 endif
+ifdef NO_C99_FORMAT
+        CFLAGS += -DNO_C99_FORMAT
+endif
 ifdef NO_OPENSSL
         CFLAGS += -DNO_OPENSSL
         GIT_OPTIONS += NO_OPENSSL=1
 else
         EXTLIBS += -lcrypto
 endif
 
 cgit: $(OBJECTS) libgit
         $(QUIET_CC)$(CC) $(CFLAGS) $(LDFLAGS) -o cgit $(OBJECTS) $(EXTLIBS)
 
 cgit.o: VERSION
 
 ifneq "$(MAKECMDGOALS)" "clean"
   -include $(OBJECTS:.o=.d)
 endif
 
 libgit:
         $(QUIET_SUBDIR0)git $(QUIET_SUBDIR1) NO_CURL=1 $(GIT_OPTIONS) libgit.a
         $(QUIET_SUBDIR0)git $(QUIET_SUBDIR1) NO_CURL=1 $(GIT_OPTIONS) xdiff/lib.a
 
 test: all
         $(QUIET_SUBDIR0)tests $(QUIET_SUBDIR1) all
 
 install: all
         $(INSTALL) -m 0755 -d $(DESTDIR)$(CGIT_SCRIPT_PATH)
         $(INSTALL) -m 0755 cgit $(DESTDIR)$(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME)
         $(INSTALL) -m 0755 -d $(DESTDIR)$(CGIT_DATA_PATH)
         $(INSTALL) -m 0644 cgit.css $(DESTDIR)$(CGIT_DATA_PATH)/cgit.css
         $(INSTALL) -m 0644 cgit.png $(DESTDIR)$(CGIT_DATA_PATH)/cgit.png
 
 uninstall:
         rm -f $(CGIT_SCRIPT_PATH)/$(CGIT_SCRIPT_NAME)
         rm -f $(CGIT_DATA_PATH)/cgit.css
         rm -f $(CGIT_DATA_PATH)/cgit.png
 
 doc: man-doc html-doc pdf-doc
 
 man-doc: cgitrc.5.txt
         a2x -f manpage cgitrc.5.txt
 
 html-doc: cgitrc.5.txt
         a2x -f xhtml --stylesheet=cgit-doc.css cgitrc.5.txt
 
 pdf-doc: cgitrc.5.txt
         a2x -f pdf cgitrc.5.txt
 
 clean: clean-doc
         rm -f cgit VERSION *.o *.d
 
 clean-doc:
         rm -f cgitrc.5 cgitrc.5.html cgitrc.5.pdf cgitrc.5.xml cgitrc.5.fo
 
 get-git:
         curl $(GIT_URL) | tar -xj && rm -rf git && mv git-$(GIT_VER) git
diff --git a/cgit.c b/cgit.c
index d6146e2..3b3f8d9 100644
--- a/cgit.c
+++ b/cgit.c
@@ -517,193 +517,193 @@ char *get_first_line(char *txt)
 }
 
 void print_repo(FILE *f, struct cgit_repo *repo)
 {
         fprintf(f, "repo.url=%s\n", repo->url);
         fprintf(f, "repo.name=%s\n", repo->name);
         fprintf(f, "repo.path=%s\n", repo->path);
         if (repo->owner)
                 fprintf(f, "repo.owner=%s\n", repo->owner);
         if (repo->desc) {
                 char *tmp = get_first_line(repo->desc);
                 fprintf(f, "repo.desc=%s\n", tmp);
                 free(tmp);
         }
         if (repo->readme)
                 fprintf(f, "repo.readme=%s\n", repo->readme);
         if (repo->defbranch)
                 fprintf(f, "repo.defbranch=%s\n", repo->defbranch);
         if (repo->module_link)
                 fprintf(f, "repo.module-link=%s\n", repo->module_link);
         if (repo->section)
                 fprintf(f, "repo.section=%s\n", repo->section);
         if (repo->clone_url)
                 fprintf(f, "repo.clone-url=%s\n", repo->clone_url);
         fprintf(f, "repo.enable-log-filecount=%d\n",
                 repo->enable_log_filecount);
         fprintf(f, "repo.enable-log-linecount=%d\n",
                 repo->enable_log_linecount);
         if (repo->about_filter && repo->about_filter != ctx.cfg.about_filter)
                 fprintf(f, "repo.about-filter=%s\n", repo->about_filter->cmd);
         if (repo->commit_filter && repo->commit_filter != ctx.cfg.commit_filter)
                 fprintf(f, "repo.commit-filter=%s\n", repo->commit_filter->cmd);
         if (repo->source_filter && repo->source_filter != ctx.cfg.source_filter)
                 fprintf(f, "repo.source-filter=%s\n", repo->source_filter->cmd);
         if (repo->snapshots != ctx.cfg.snapshots) {
                 char *tmp = build_snapshot_setting(repo->snapshots);
                 fprintf(f, "repo.snapshots=%s\n", tmp);
                 free(tmp);
         }
         if (repo->max_stats != ctx.cfg.max_stats)
                 fprintf(f, "repo.max-stats=%s\n",
                         cgit_find_stats_periodname(repo->max_stats));
         fprintf(f, "\n");
 }
 
 void print_repolist(FILE *f, struct cgit_repolist *list, int start)
 {
         int i;
 
         for(i = start; i < list->count; i++)
                 print_repo(f, &list->repos[i]);
 }
 
 /* Scan 'path' for git repositories, save the resulting repolist in 'cached_rc'
  * and return 0 on success.
  */
 static int generate_cached_repolist(const char *path, const char *cached_rc)
 {
         char *locked_rc;
         int idx;
         FILE *f;
 
         locked_rc = xstrdup(fmt("%s.lock", cached_rc));
         f = fopen(locked_rc, "wx");
         if (!f) {
                 /* Inform about the error unless the lockfile already existed,
                  * since that only means we've got concurrent requests.
                  */
                 if (errno != EEXIST)
                         fprintf(stderr, "[cgit] Error opening %s: %s (%d)\n",
                                 locked_rc, strerror(errno), errno);
                 return errno;
         }
         idx = cgit_repolist.count;
         if (ctx.cfg.project_list)
                 scan_projects(path, ctx.cfg.project_list, repo_config);
         else
                 scan_tree(path, repo_config);
         print_repolist(f, &cgit_repolist, idx);
         if (rename(locked_rc, cached_rc))
                 fprintf(stderr, "[cgit] Error renaming %s to %s: %s (%d)\n",
                         locked_rc, cached_rc, strerror(errno), errno);
         fclose(f);
         return 0;
 }
 
 static void process_cached_repolist(const char *path)
 {
         struct stat st;
         char *cached_rc;
         time_t age;
         unsigned long hash;
 
         hash = hash_str(path);
         if (ctx.cfg.project_list)
                 hash += hash_str(ctx.cfg.project_list);
-        cached_rc = xstrdup(fmt("%s/rc-%8x", ctx.cfg.cache_root, hash));
+        cached_rc = xstrdup(fmt("%s/rc-%8lx", ctx.cfg.cache_root, hash));
 
         if (stat(cached_rc, &st)) {
                 /* Nothing is cached, we need to scan without forking. And
                  * if we fail to generate a cached repolist, we need to
                  * invoke scan_tree manually.
                  */
                 if (generate_cached_repolist(path, cached_rc)) {
                         if (ctx.cfg.project_list)
                                 scan_projects(path, ctx.cfg.project_list,
                                               repo_config);
                         else
                                 scan_tree(path, repo_config);
                 }
                 return;
         }
 
         parse_configfile(cached_rc, config_cb);
 
         /* If the cached configfile hasn't expired, lets exit now */
         age = time(NULL) - st.st_mtime;
         if (age <= (ctx.cfg.cache_scanrc_ttl * 60))
                 return;
 
         /* The cached repolist has been parsed, but it was old. So lets
          * rescan the specified path and generate a new cached repolist
          * in a child-process to avoid latency for the current request.
          */
         if (fork())
                 return;
 
         exit(generate_cached_repolist(path, cached_rc));
 }
 
 static void cgit_parse_args(int argc, const char **argv)
 {
         int i;
         int scan = 0;
 
         for (i = 1; i < argc; i++) {
                 if (!strncmp(argv[i], "--cache=", 8)) {
                         ctx.cfg.cache_root = xstrdup(argv[i]+8);
                 }
                 if (!strcmp(argv[i], "--nocache")) {
                         ctx.cfg.nocache = 1;
                 }
                 if (!strcmp(argv[i], "--nohttp")) {
                         ctx.env.no_http = "1";
                 }
                 if (!strncmp(argv[i], "--query=", 8)) {
                         ctx.qry.raw = xstrdup(argv[i]+8);
                 }
                 if (!strncmp(argv[i], "--repo=", 7)) {
                         ctx.qry.repo = xstrdup(argv[i]+7);
                 }
                 if (!strncmp(argv[i], "--page=", 7)) {
                         ctx.qry.page = xstrdup(argv[i]+7);
                 }
                 if (!strncmp(argv[i], "--head=", 7)) {
                         ctx.qry.head = xstrdup(argv[i]+7);
                         ctx.qry.has_symref = 1;
                 }
                 if (!strncmp(argv[i], "--sha1=", 7)) {
                         ctx.qry.sha1 = xstrdup(argv[i]+7);
                         ctx.qry.has_sha1 = 1;
                 }
                 if (!strncmp(argv[i], "--ofs=", 6)) {
                         ctx.qry.ofs = atoi(argv[i]+6);
                 }
                 if (!strncmp(argv[i], "--scan-tree=", 12) ||
                     !strncmp(argv[i], "--scan-path=", 12)) {
                         /* HACK: the global snapshot bitmask defines the
                          * set of allowed snapshot formats, but the config
                          * file hasn't been parsed yet so the mask is
                          * currently 0. By setting all bits high before
                          * scanning we make sure that any in-repo cgitrc
                          * snapshot setting is respected by scan_tree().
                          * BTW: we assume that there'll never be more than
                          * 255 different snapshot formats supported by cgit...
                          */
                         ctx.cfg.snapshots = 0xFF;
                         scan++;
                         scan_tree(argv[i] + 12, repo_config);
                 }
         }
         if (scan) {
                 qsort(cgit_repolist.repos, cgit_repolist.count,
                         sizeof(struct cgit_repo), cmp_repos);
                 print_repolist(stdout, &cgit_repolist, 0);
                 exit(0);
         }
 }
 
 static int calc_ttl()
 {
         if (!ctx.repo)
                 return ctx.cfg.cache_root_ttl;
diff --git a/ui-diff.c b/ui-diff.c
index 0dcabe9..7ff7e46 100644
--- a/ui-diff.c
+++ b/ui-diff.c
@@ -1,191 +1,191 @@
 /* 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"
 #include "ui-ssdiff.h"
 
 unsigned char old_rev_sha1[20];
 unsigned char new_rev_sha1[20];
 
 static int files, slots;
 static int total_adds, total_rems, max_changes;
 static int lines_added, lines_removed;
 
 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;
         unsigned long old_size;
         unsigned long new_size;
         int binary:1;
 } *items;
 
 static int use_ssdiff = 0;
 
 static 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;
         default:
                 die("bug: unhandled diff status %c", info->status);
         }
 
         html("<tr>");
         htmlf("<td class='mode'>");
         if (is_null_sha1(info->new_sha1)) {
                 cgit_print_filemode(info->old_mode);
         } else {
                 cgit_print_filemode(info->new_mode);
         }
 
         if (info->old_mode != info->new_mode &&
             !is_null_sha1(info->old_sha1) &&
             !is_null_sha1(info->new_sha1)) {
                 html("<span class='modechange'>[");
                 cgit_print_filemode(info->old_mode);
                 html("]</span>");
         }
         htmlf("</td><td class='%s'>", class);
         cgit_diff_link(info->new_path, NULL, NULL, ctx.qry.head, ctx.qry.sha1,
                        ctx.qry.sha2, info->new_path, 0);
         if (info->status == DIFF_STATUS_COPIED || info->status == DIFF_STATUS_RENAMED)
                 htmlf(" (%s from %s)",
                       info->status == DIFF_STATUS_COPIED ? "copied" : "renamed",
                       info->old_path);
         html("</td><td class='right'>");
         if (info->binary) {
-                htmlf("bin</td><td class='graph'>%d -> %d bytes",
+                htmlf("bin</td><td class='graph'>%ld -> %ld bytes",
                       info->old_size, info->new_size);
                 return;
         }
         htmlf("%d", info->added + info->removed);
         html("</td><td class='graph'>");
         htmlf("<table summary='file diffstat' width='%d%%'><tr>", (max_changes > 100 ? 100 : max_changes));
         htmlf("<td class='add' style='width: %.1f%%;'/>",
               info->added * 100.0 / max_changes);
         htmlf("<td class='rem' style='width: %.1f%%;'/>",
               info->removed * 100.0 / max_changes);
         htmlf("<td class='none' style='width: %.1f%%;'/>",
               (max_changes - info->removed - info->added) * 100.0 / max_changes);
         html("</tr></table></td></tr>\n");
 }
 
 static void count_diff_lines(char *line, int len)
 {
         if (line && (len > 0)) {
                 if (line[0] == '+')
                         lines_added++;
                 else if (line[0] == '-')
                         lines_removed++;
         }
 }
 
 static void inspect_filepair(struct diff_filepair *pair)
 {
         int binary = 0;
         unsigned long old_size = 0;
         unsigned long new_size = 0;
         files++;
         lines_added = 0;
         lines_removed = 0;
         cgit_diff_files(pair->one->sha1, pair->two->sha1, &old_size, &new_size,
                         &binary, 0, ctx.qry.ignorews, count_diff_lines);
         if (files >= slots) {
                 if (slots == 0)
                         slots = 4;
                 else
                         slots = slots * 2;
                 items = xrealloc(items, slots * sizeof(struct fileinfo));
         }
         items[files-1].status = pair->status;
         hashcpy(items[files-1].old_sha1, pair->one->sha1);
         hashcpy(items[files-1].new_sha1, pair->two->sha1);
         items[files-1].old_mode = pair->one->mode;
         items[files-1].new_mode = pair->two->mode;
         items[files-1].old_path = xstrdup(pair->one->path);
         items[files-1].new_path = xstrdup(pair->two->path);
         items[files-1].added = lines_added;
         items[files-1].removed = lines_removed;
         items[files-1].old_size = old_size;
         items[files-1].new_size = new_size;
         items[files-1].binary = binary;
         if (lines_added + lines_removed > max_changes)
                 max_changes = lines_added + lines_removed;
         total_adds += lines_added;
         total_rems += lines_removed;
 }
 
 void cgit_print_diffstat(const unsigned char *old_sha1,
                          const unsigned char *new_sha1, const char *prefix)
 {
         int i, save_context = ctx.qry.context;
 
         html("<div class='diffstat-header'>");
         cgit_diff_link("Diffstat", NULL, NULL, ctx.qry.head, ctx.qry.sha1,
                        ctx.qry.sha2, NULL, 0);
         if (prefix)
                 htmlf(" (limited to '%s')", prefix);
         html(" (");
         ctx.qry.context = (save_context > 0 ? save_context : 3) << 1;
         cgit_self_link("more", NULL, NULL, &ctx);
         html("/");
         ctx.qry.context = (save_context > 3 ? save_context : 3) >> 1;
         cgit_self_link("less", NULL, NULL, &ctx);
         ctx.qry.context = save_context;
         html(" context)");
         html(" (");
         ctx.qry.ignorews = (ctx.qry.ignorews + 1) % 2;
         cgit_self_link(ctx.qry.ignorews ? "ignore" : "show", NULL, NULL, &ctx);
         ctx.qry.ignorews = (ctx.qry.ignorews + 1) % 2;
         html(" whitespace changes)");
         html("</div>");
         html("<table summary='diffstat' class='diffstat'>");
         max_changes = 0;
         cgit_diff_tree(old_sha1, new_sha1, inspect_filepair, prefix,
                        ctx.qry.ignorews);
         for(i = 0; i<files; i++)
                 print_fileinfo(&items[i]);
         html("</table>");
         html("<div class='diffstat-summary'>");
         htmlf("%d files changed, %d insertions, %d deletions",
               files, total_adds, total_rems);
         html("</div>");
 }
diff --git a/ui-log.c b/ui-log.c
index 0536b23..41b5225 100644
--- a/ui-log.c
+++ b/ui-log.c
@@ -135,119 +135,118 @@ void print_commit(struct commit *commit)
         }
         cgit_free_commitinfo(info);
 }
 
 static const char *disambiguate_ref(const char *ref)
 {
         unsigned char sha1[20];
         const char *longref;
 
         longref = fmt("refs/heads/%s", ref);
         if (get_sha1(longref, sha1) == 0)
                 return longref;
 
         return ref;
 }
 
 void cgit_print_log(const char *tip, int ofs, int cnt, char *grep, char *pattern,
                     char *path, int pager)
 {
         struct rev_info rev;
         struct commit *commit;
         const char *argv[] = {NULL, NULL, NULL, NULL, NULL};
         int argc = 2;
         int i, columns = 3;
 
         if (!tip)
                 tip = ctx.qry.head;
 
         argv[1] = disambiguate_ref(tip);
 
         if (grep && pattern) {
                 if (!strcmp(grep, "grep") || !strcmp(grep, "author") ||
                     !strcmp(grep, "committer"))
                         argv[argc++] = fmt("--%s=%s", grep, pattern);
                 if (!strcmp(grep, "range"))
                         argv[1] = pattern;
         }
 
         if (path) {
                 argv[argc++] = "--";
                 argv[argc++] = path;
         }
         init_revisions(&rev, NULL);
         rev.abbrev = DEFAULT_ABBREV;
         rev.commit_format = CMIT_FMT_DEFAULT;
         rev.verbose_header = 1;
         rev.show_root_diff = 0;
         setup_revisions(argc, argv, &rev, NULL);
         load_ref_decorations(DECORATE_FULL_REFS);
         rev.show_decorations = 1;
         rev.grep_filter.regflags |= REG_ICASE;
         compile_grep_patterns(&rev.grep_filter);
         prepare_revision_walk(&rev);
 
         if (pager)
                 html("<table class='list nowrap'>");
 
         html("<tr class='nohover'><th class='left'>Age</th>"
               "<th class='left'>Commit 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);
                 html(")");
         }
         html("</th><th class='left'>Author</th>");
         if (ctx.repo->enable_log_filecount) {
                 html("<th class='left'>Files</th>");
                 columns++;
                 if (ctx.repo->enable_log_linecount) {
                         html("<th class='left'>Lines</th>");
                         columns++;
                 }
         }
         html("</tr>\n");
 
         if (ofs<0)
                 ofs = 0;
 
         for (i = 0; i < ofs && (commit = get_revision(&rev)) != NULL; i++) {
                 free(commit->buffer);
                 commit->buffer = NULL;
                 free_commit_list(commit->parents);
                 commit->parents = NULL;
         }
 
         for (i = 0; i < cnt && (commit = get_revision(&rev)) != NULL; i++) {
                 print_commit(commit);
                 free(commit->buffer);
                 commit->buffer = NULL;
                 free_commit_list(commit->parents);
                 commit->parents = NULL;
         }
         if (pager) {
-                htmlf("</table><div class='pager'>",
-                     columns);
+                html("</table><div class='pager'>");
                 if (ofs > 0) {
                         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);
                         html("&nbsp;");
                 }
                 if ((commit = get_revision(&rev)) != NULL) {
                         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);
                 }
                 html("</div>");
         } else if ((commit = get_revision(&rev)) != NULL) {
                 html("<tr class='nohover'><td colspan='3'>");
                 cgit_log_link("[...]", NULL, NULL, ctx.qry.head, NULL,
                               ctx.qry.vpath, 0, NULL, NULL, ctx.qry.showmsg);
                 html("</td></tr>\n");
         }
 }
diff --git a/ui-stats.c b/ui-stats.c
index 50c2540..946a6ea 100644
--- a/ui-stats.c
+++ b/ui-stats.c
@@ -1,103 +1,109 @@
 #include <string-list.h>
 
 #include "cgit.h"
 #include "html.h"
 #include "ui-shared.h"
 #include "ui-stats.h"
 
+#ifdef NO_C99_FORMAT
+#define SZ_FMT "%u"
+#else
+#define SZ_FMT "%zu"
+#endif
+
 #define MONTHS 6
 
 struct authorstat {
         long total;
         struct string_list list;
 };
 
 #define DAY_SECS (60 * 60 * 24)
 #define WEEK_SECS (DAY_SECS * 7)
 
 static void trunc_week(struct tm *tm)
 {
         time_t t = timegm(tm);
         t -= ((tm->tm_wday + 6) % 7) * DAY_SECS;
                 gmtime_r(&t, tm);
 }
 
 static void dec_week(struct tm *tm)
 {
         time_t t = timegm(tm);
         t -= WEEK_SECS;
                 gmtime_r(&t, tm);
 }
 
 static void inc_week(struct tm *tm)
 {
         time_t t = timegm(tm);
         t += WEEK_SECS;
                 gmtime_r(&t, tm);
 }
 
 static char *pretty_week(struct tm *tm)
 {
         static char buf[10];
 
         strftime(buf, sizeof(buf), "W%V %G", tm);
         return buf;
 }
 
 static void trunc_month(struct tm *tm)
 {
         tm->tm_mday = 1;
 }
 
 static void dec_month(struct tm *tm)
 {
         tm->tm_mon--;
         if (tm->tm_mon < 0) {
                 tm->tm_year--;
                 tm->tm_mon = 11;
         }
 }
 
 static void inc_month(struct tm *tm)
 {
         tm->tm_mon++;
         if (tm->tm_mon > 11) {
                 tm->tm_year++;
                 tm->tm_mon = 0;
         }
 }
 
 static char *pretty_month(struct tm *tm)
 {
         static const char *months[] = {
                 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
                 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
         };
         return fmt("%s %d", months[tm->tm_mon], tm->tm_year + 1900);
 }
 
 static void trunc_quarter(struct tm *tm)
 {
         trunc_month(tm);
         while(tm->tm_mon % 3 != 0)
                 dec_month(tm);
 }
 
 static void dec_quarter(struct tm *tm)
 {
         dec_month(tm);
         dec_month(tm);
         dec_month(tm);
 }
 
 static void inc_quarter(struct tm *tm)
 {
         inc_month(tm);
         inc_month(tm);
         inc_month(tm);
 }
 
 static char *pretty_quarter(struct tm *tm)
 {
         return fmt("Q%d %d", tm->tm_mon / 3 + 1, tm->tm_year + 1900);
 }
@@ -190,229 +196,229 @@ static void add_commit(struct string_list *authors, struct commit *commit,
         if (item->util)
                 free(tmp);
         item->util++;
         authorstat->total++;
         cgit_free_commitinfo(info);
 }
 
 static int cmp_total_commits(const void *a1, const void *a2)
 {
         const struct string_list_item *i1 = a1;
         const struct string_list_item *i2 = a2;
         const struct authorstat *auth1 = i1->util;
         const struct authorstat *auth2 = i2->util;
 
         return auth2->total - auth1->total;
 }
 
 /* Walk the commit DAG and collect number of commits per author per
  * timeperiod into a nested string_list collection.
  */
 struct string_list collect_stats(struct cgit_context *ctx,
         struct cgit_period *period)
 {
         struct string_list authors;
         struct rev_info rev;
         struct commit *commit;
         const char *argv[] = {NULL, ctx->qry.head, NULL, NULL, NULL, NULL};
         int argc = 3;
         time_t now;
         long i;
         struct tm *tm;
         char tmp[11];
 
         time(&now);
         tm = gmtime(&now);
         period->trunc(tm);
         for (i = 1; i < period->count; i++)
                 period->dec(tm);
         strftime(tmp, sizeof(tmp), "%Y-%m-%d", tm);
         argv[2] = xstrdup(fmt("--since=%s", tmp));
         if (ctx->qry.path) {
                 argv[3] = "--";
                 argv[4] = ctx->qry.path;
                 argc += 2;
         }
         init_revisions(&rev, NULL);
         rev.abbrev = DEFAULT_ABBREV;
         rev.commit_format = CMIT_FMT_DEFAULT;
         rev.no_merges = 1;
         rev.verbose_header = 1;
         rev.show_root_diff = 0;
         setup_revisions(argc, argv, &rev, NULL);
         prepare_revision_walk(&rev);
         memset(&authors, 0, sizeof(authors));
         while ((commit = get_revision(&rev)) != NULL) {
                 add_commit(&authors, commit, period);
                 free(commit->buffer);
                 free_commit_list(commit->parents);
         }
         return authors;
 }
 
 void print_combined_authorrow(struct string_list *authors, int from, int to,
         const char *name, const char *leftclass, const char *centerclass,
         const char *rightclass, struct cgit_period *period)
 {
         struct string_list_item *author;
         struct authorstat *authorstat;
         struct string_list *items;
         struct string_list_item *date;
         time_t now;
         long i, j, total, subtotal;
         struct tm *tm;
         char *tmp;
 
         time(&now);
         tm = gmtime(&now);
         period->trunc(tm);
         for (i = 1; i < period->count; i++)
                 period->dec(tm);
 
         total = 0;
         htmlf("<tr><td class='%s'>%s</td>", leftclass,
                 fmt(name, to - from + 1));
         for (j = 0; j < period->count; j++) {
                 tmp = period->pretty(tm);
                 period->inc(tm);
                 subtotal = 0;
                 for (i = from; i <= to; i++) {
                         author = &authors->items[i];
                         authorstat = author->util;
                         items = &authorstat->list;
                         date = string_list_lookup(items, tmp);
                         if (date)
                                 subtotal += (size_t)date->util;
                 }
-                htmlf("<td class='%s'>%d</td>", centerclass, subtotal);
+                htmlf("<td class='%s'>%ld</td>", centerclass, subtotal);
                 total += subtotal;
         }
-        htmlf("<td class='%s'>%d</td></tr>", rightclass, total);
+        htmlf("<td class='%s'>%ld</td></tr>", rightclass, total);
 }
 
 void print_authors(struct string_list *authors, int top,
                    struct cgit_period *period)
 {
         struct string_list_item *author;
         struct authorstat *authorstat;
         struct string_list *items;
         struct string_list_item *date;
         time_t now;
         long i, j, total;
         struct tm *tm;
         char *tmp;
 
         time(&now);
         tm = gmtime(&now);
         period->trunc(tm);
         for (i = 1; i < period->count; i++)
                 period->dec(tm);
 
         html("<table class='stats'><tr><th>Author</th>");
         for (j = 0; j < period->count; j++) {
                 tmp = period->pretty(tm);
                 htmlf("<th>%s</th>", tmp);
                 period->inc(tm);
         }
         html("<th>Total</th></tr>\n");
 
         if (top <= 0 || top > authors->nr)
                 top = authors->nr;
 
         for (i = 0; i < top; i++) {
                 author = &authors->items[i];
                 html("<tr><td class='left'>");
                 html_txt(author->string);
                 html("</td>");
                 authorstat = author->util;
                 items = &authorstat->list;
                 total = 0;
                 for (j = 0; j < period->count; j++)
                         period->dec(tm);
                 for (j = 0; j < period->count; j++) {
                         tmp = period->pretty(tm);
                         period->inc(tm);
                         date = string_list_lookup(items, tmp);
                         if (!date)
                                 html("<td>0</td>");
                         else {
-                                htmlf("<td>%d</td>", date->util);
+                                htmlf("<td>"SZ_FMT"</td>", (size_t)date->util);
                                 total += (size_t)date->util;
                         }
                 }
-                htmlf("<td class='sum'>%d</td></tr>", total);
+                htmlf("<td class='sum'>%ld</td></tr>", total);
         }
 
         if (top < authors->nr)
                 print_combined_authorrow(authors, top, authors->nr - 1,
-                        "Others (%d)", "left", "", "sum", period);
+                        "Others (%ld)", "left", "", "sum", period);
 
         print_combined_authorrow(authors, 0, authors->nr - 1, "Total",
                 "total", "sum", "sum", period);
         html("</table>");
 }
 
 /* Create a sorted string_list with one entry per author. The util-field
  * for each author is another string_list which is used to calculate the
  * number of commits per time-interval.
  */
 void cgit_show_stats(struct cgit_context *ctx)
 {
         struct string_list authors;
         struct cgit_period *period;
         int top, i;
         const char *code = "w";
 
         if (ctx->qry.period)
                 code = ctx->qry.period;
 
         i = cgit_find_stats_period(code, &period);
         if (!i) {
-                cgit_print_error(fmt("Unknown statistics type: %c", code));
+                cgit_print_error(fmt("Unknown statistics type: %c", code[0]));
                 return;
         }
         if (i > ctx->repo->max_stats) {
                 cgit_print_error(fmt("Statistics type disabled: %s",
                                      period->name));
                 return;
         }
         authors = collect_stats(ctx, period);
         qsort(authors.items, authors.nr, sizeof(struct string_list_item),
                 cmp_total_commits);
 
         top = ctx->qry.ofs;
         if (!top)
                 top = 10;
         htmlf("<h2>Commits per author per %s", period->name);
         if (ctx->qry.path) {
                 html(" (path '");
                 html_txt(ctx->qry.path);
                 html("')");
         }
         html("</h2>");
 
         html("<form method='get' action='' style='float: right; text-align: right;'>");
         cgit_add_hidden_formfields(1, 0, "stats");
         if (ctx->repo->max_stats > 1) {
                 html("Period: ");
                 html("<select name='period' onchange='this.form.submit();'>");
                 for (i = 0; i < ctx->repo->max_stats; i++)
                         htmlf("<option value='%c'%s>%s</option>",
                                 periods[i].code,
                                 period == &periods[i] ? " selected" : "",
                                 periods[i].name);
                 html("</select><br/><br/>");
         }
         html("Authors: ");
         html("");
         html("<select name='ofs' onchange='this.form.submit();'>");
         htmlf("<option value='10'%s>10</option>", top == 10 ? " selected" : "");
         htmlf("<option value='25'%s>25</option>", top == 25 ? " selected" : "");
         htmlf("<option value='50'%s>50</option>", top == 50 ? " selected" : "");
         htmlf("<option value='100'%s>100</option>", top == 100 ? " selected" : "");
         htmlf("<option value='-1'%s>All</option>", top == -1 ? " selected" : "");
         html("</select>");
         html("<noscript>&nbsp;&nbsp;<input type='submit' value='Reload'/></noscript>");
         html("</form>");
         print_authors(&authors, top, period);
 }
 
diff --git a/ui-tree.c b/ui-tree.c
index 75ec9cb..0cdbf6d 100644
--- a/ui-tree.c
+++ b/ui-tree.c
@@ -1,207 +1,207 @@
 /* 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 <ctype.h>
 #include "cgit.h"
 #include "html.h"
 #include "ui-shared.h"
 
 char *curr_rev;
 char *match_path;
 int header = 0;
 
 static void print_text_buffer(const char *name, char *buf, unsigned long size)
 {
         unsigned long lineno, idx;
         const char *numberfmt =
                 "<a class='no' id='n%1$d' name='n%1$d' href='#n%1$d'>%1$d</a>\n";
 
         html("<table summary='blob content' class='blob'>\n");
 
         if (ctx.cfg.enable_tree_linenumbers) {
                 html("<tr><td class='linenumbers'><pre>");
                 idx = 0;
                 lineno = 0;
         
                 if (size) {
                         htmlf(numberfmt, ++lineno);
                         while(idx < size - 1) { // skip absolute last newline
                                 if (buf[idx] == '\n')
                                         htmlf(numberfmt, ++lineno);
                                 idx++;
                         }
                 }
                 html("</pre></td>\n");
         }
         else {
                 html("<tr>\n");
         }
 
         if (ctx.repo->source_filter) {
                 html("<td class='lines'><pre><code>");
                 ctx.repo->source_filter->argv[1] = xstrdup(name);
                 cgit_open_filter(ctx.repo->source_filter);
                 write(STDOUT_FILENO, buf, size);
                 cgit_close_filter(ctx.repo->source_filter);
                 html("</code></pre></td></tr></table>\n");
                 return;
         }
 
         html("<td class='lines'><pre><code>");
         html_txt(buf);
         html("</code></pre></td></tr></table>\n");
 }
 
 #define ROWLEN 32
 
 static void print_binary_buffer(char *buf, unsigned long size)
 {
         unsigned long ofs, idx;
         static char ascii[ROWLEN + 1];
 
         html("<table summary='blob content' class='bin-blob'>\n");
         html("<tr><th>ofs</th><th>hex dump</th><th>ascii</th></tr>");
         for (ofs = 0; ofs < size; ofs += ROWLEN, buf += ROWLEN) {
-                htmlf("<tr><td class='right'>%04x</td><td class='hex'>", ofs);
+                htmlf("<tr><td class='right'>%04lx</td><td class='hex'>", ofs);
                 for (idx = 0; idx < ROWLEN && ofs + idx < size; idx++)
                         htmlf("%*s%02x",
                               idx == 16 ? 4 : 1, "",
                               buf[idx] & 0xff);
                 html(" </td><td class='hex'>");
                 for (idx = 0; idx < ROWLEN && ofs + idx < size; idx++)
                         ascii[idx] = isgraph(buf[idx]) ? buf[idx] : '.';
                 ascii[idx] = '\0';
                 html_txt(ascii);
                 html("</td></tr>\n");
         }
         html("</table>\n");
 }
 
 static void print_object(const unsigned char *sha1, char *path, const char *basename)
 {
         enum object_type type;
         char *buf;
         unsigned long size;
 
         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;
         }
 
         htmlf("blob: %s (", sha1_to_hex(sha1));
         cgit_plain_link("plain", NULL, NULL, ctx.qry.head,
                         curr_rev, path);
         html(")\n");
 
         if (ctx.cfg.max_blob_size && size / 1024 > ctx.cfg.max_blob_size) {
-                htmlf("<div class='error'>blob size (%dKB) exceeds display size limit (%dKB).</div>",
+                htmlf("<div class='error'>blob size (%ldKB) exceeds display size limit (%dKB).</div>",
                                 size / 1024, ctx.cfg.max_blob_size);
                 return;
         }
 
         if (buffer_is_binary(buf, size))
                 print_binary_buffer(buf, size);
         else
                 print_text_buffer(basename, buf, size);
 }
 
 
 static int ls_item(const unsigned char *sha1, const char *base, int baselen,
                    const char *pathname, unsigned int mode, int stage,
                    void *cbdata)
 {
         char *name;
         char *fullpath;
         char *class;
         enum object_type type;
         unsigned long size = 0;
 
         name = xstrdup(pathname);
         fullpath = fmt("%s%s%s", ctx.qry.path ? ctx.qry.path : "",
                        ctx.qry.path ? "/" : "", name);
 
         if (!S_ISGITLINK(mode)) {
                 type = sha1_object_info(sha1, &size);
                 if (type == OBJ_BAD) {
                         htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>",
                               name,
                               sha1_to_hex(sha1));
                         return 0;
                 }
         }
 
         html("<tr><td class='ls-mode'>");
         cgit_print_filemode(mode);
         html("</td><td>");
         if (S_ISGITLINK(mode)) {
                 htmlf("<a class='ls-mod' href='");
                 html_attr(fmt(ctx.repo->module_link,
                               name,
                               sha1_to_hex(sha1)));
                 html("'>");
                 html_txt(name);
                 html("</a>");
         } else if (S_ISDIR(mode)) {
                 cgit_tree_link(name, NULL, "ls-dir", ctx.qry.head,
                                curr_rev, fullpath);
         } else {
                 class = strrchr(name, '.');
                 if (class != NULL) {
                         class = fmt("ls-blob %s", class + 1);
                 } else
                         class = "ls-blob";
                 cgit_tree_link(name, NULL, class, ctx.qry.head,
                                curr_rev, fullpath);
         }
         htmlf("</td><td class='ls-size'>%li</td>", size);
 
         html("<td>");
         cgit_log_link("log", NULL, "button", ctx.qry.head, curr_rev,
                       fullpath, 0, NULL, NULL, ctx.qry.showmsg);
         if (ctx.repo->max_stats)
                 cgit_stats_link("stats", NULL, "button", ctx.qry.head,
                                 fullpath);
         cgit_plain_link("plain", NULL, "button", ctx.qry.head, curr_rev,
                         fullpath);
         html("</td></tr>\n");
         free(name);
         return 0;
 }
 
 static void ls_head()
 {
         html("<table summary='tree listing' class='list'>\n");
         html("<tr class='nohover'>");
         html("<th class='left'>Mode</th>");
         html("<th class='left'>Name</th>");
         html("<th class='right'>Size</th>");
         html("<th/>");
         html("</tr>\n");
         header = 1;
 }
 
 static void ls_tail()
 {
         if (!header)
                 return;
         html("</table>\n");
         header = 0;
 }
 
 static void ls_tree(const unsigned char *sha1, char *path)
 {
         struct tree *tree;