fix building with clang

[ps-cgit] / ui-tree.c

diff --git a/ui-tree.c b/ui-tree.c
index ca24a035c57cbe4a27acae26bab4191c781f565c..064033622355e4a30dce22e5d6d27f1fa38b44ec 100644 (file)
--- a/ui-tree.c
+++ b/ui-tree.c
@@ -1,6 +1,6 @@
 /* ui-tree.c: functions for tree output
  *
 /* ui-tree.c: functions for tree output
  *

- * Copyright (C) 2006-2014 cgit Development Team <cgit@lists.zx2c4.com>
+ * Copyright (C) 2006-2017 cgit Development Team <cgit@lists.zx2c4.com>

  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)
  *
  * Licensed under GNU General Public License v2
  *   (see COPYING for full license text)


@@ -84,63 +84,39 @@ static void print_binary_buffer(char *buf, unsigned long size)
        html("</table>\n");
 }
 
        html("</table>\n");
 }
 

-static void set_title_from_path(const char *path)
-{
-       size_t path_len, path_index, path_last_end;
-       char *new_title;
-
-       if (!path)
-               return;
-
-       path_len = strlen(path);
-       new_title = xmalloc(path_len + 3 + strlen(ctx.page.title) + 1);
-       new_title[0] = '\0';
-
-       for (path_index = path_len, path_last_end = path_len; path_index-- > 0;) {
-               if (path[path_index] == '/') {
-                       if (path_index == path_len - 1) {
-                               path_last_end = path_index - 1;
-                               continue;
-                       }
-                       strncat(new_title, &path[path_index + 1], path_last_end - path_index - 1);
-                       strcat(new_title, "\\");
-                       path_last_end = path_index;
-               }
-       }
-       if (path_last_end)
-               strncat(new_title, path, path_last_end);
-
-       strcat(new_title, " - ");
-       strcat(new_title, ctx.page.title);
-       ctx.page.title = new_title;
-}
-
-static void print_object(const unsigned char *sha1, char *path, const char *basename, const char *rev)
+static void print_object(const struct object_id *oid, const char *path, const char *basename, const char *rev)

 {
        enum object_type type;
        char *buf;
        unsigned long size;
 {
        enum object_type type;
        char *buf;
        unsigned long size;

+       bool is_binary;

 
 

-       type = sha1_object_info(sha1, &size);
+       type = oid_object_info(the_repository, oid, &size);

        if (type == OBJ_BAD) {
                cgit_print_error_page(404, "Not found",
        if (type == OBJ_BAD) {
                cgit_print_error_page(404, "Not found",

-                       "Bad object name: %s", sha1_to_hex(sha1));
+                       "Bad object name: %s", oid_to_hex(oid));

                return;
        }
 
                return;
        }
 

-       buf = read_sha1_file(sha1, &type, &size);
+       buf = repo_read_object_file(the_repository, oid, &type, &size);

        if (!buf) {
                cgit_print_error_page(500, "Internal server error",
        if (!buf) {
                cgit_print_error_page(500, "Internal server error",

-                       "Error reading object %s", sha1_to_hex(sha1));
+                       "Error reading object %s", oid_to_hex(oid));

                return;
        }
                return;
        }

+       is_binary = buffer_is_binary(buf, size);

 
 

-       set_title_from_path(path);
+       cgit_set_title_from_path(path);

 
        cgit_print_layout_start();
 
        cgit_print_layout_start();

-       htmlf("blob: %s (", sha1_to_hex(sha1));
+       htmlf("blob: %s (", oid_to_hex(oid));

        cgit_plain_link("plain", NULL, NULL, ctx.qry.head,
                        rev, path);
        cgit_plain_link("plain", NULL, NULL, ctx.qry.head,
                        rev, path);

+       if (ctx.repo->enable_blame && !is_binary) {
+               html(") (");
+               cgit_blame_link("blame", NULL, NULL, ctx.qry.head,
+                               rev, path);
+       }

        html(")\n");
 
        if (ctx.cfg.max_blob_size && size / 1024 > ctx.cfg.max_blob_size) {
        html(")\n");
 
        if (ctx.cfg.max_blob_size && size / 1024 > ctx.cfg.max_blob_size) {


@@ -149,10 +125,12 @@ static void print_object(const unsigned char *sha1, char *path, const char *base
                return;
        }
 
                return;
        }
 

-       if (buffer_is_binary(buf, size))
+       if (is_binary)

                print_binary_buffer(buf, size);
        else
                print_text_buffer(basename, buf, size);
                print_binary_buffer(buf, size);
        else
                print_text_buffer(basename, buf, size);

+
+       free(buf);

 }
 
 struct single_tree_ctx {
 }
 
 struct single_tree_ctx {


@@ -162,9 +140,8 @@ struct single_tree_ctx {
        size_t count;
 };
 
        size_t count;
 };
 

-static int single_tree_cb(const unsigned char *sha1, struct strbuf *base,
-                         const char *pathname, unsigned mode, int stage,
-                         void *cbdata)
+static int single_tree_cb(const struct object_id *oid, struct strbuf *base,
+                         const char *pathname, unsigned mode, void *cbdata)

 {
        struct single_tree_ctx *ctx = cbdata;
 
 {
        struct single_tree_ctx *ctx = cbdata;
 


@@ -177,12 +154,12 @@ static int single_tree_cb(const unsigned char *sha1, struct strbuf *base,
        }
 
        ctx->name = xstrdup(pathname);
        }
 
        ctx->name = xstrdup(pathname);

-       hashcpy(ctx->oid.hash, sha1);
+       oidcpy(&ctx->oid, oid);

        strbuf_addf(ctx->path, "/%s", pathname);
        return 0;
 }
 
        strbuf_addf(ctx->path, "/%s", pathname);
        return 0;
 }
 

-static void write_tree_link(const unsigned char *sha1, char *name,
+static void write_tree_link(const struct object_id *oid, char *name,

                            char *rev, struct strbuf *fullpath)
 {
        size_t initial_length = fullpath->len;
                            char *rev, struct strbuf *fullpath)
 {
        size_t initial_length = fullpath->len;


@@ -195,13 +172,13 @@ static void write_tree_link(const unsigned char *sha1, char *name,
                .nr = 0
        };
 
                .nr = 0
        };
 

-       hashcpy(tree_ctx.oid.hash, sha1);
+       oidcpy(&tree_ctx.oid, oid);

 
        while (tree_ctx.count == 1) {
                cgit_tree_link(name, NULL, "ls-dir", ctx.qry.head, rev,
                               fullpath->buf);
 
 
        while (tree_ctx.count == 1) {
                cgit_tree_link(name, NULL, "ls-dir", ctx.qry.head, rev,
                               fullpath->buf);
 

-               tree = lookup_tree(&tree_ctx.oid);
+               tree = lookup_tree(the_repository, &tree_ctx.oid);

                if (!tree)
                        return;
 
                if (!tree)
                        return;
 


@@ -209,8 +186,7 @@ static void write_tree_link(const unsigned char *sha1, char *name,
                tree_ctx.name = NULL;
                tree_ctx.count = 0;
 
                tree_ctx.name = NULL;
                tree_ctx.count = 0;
 

-               read_tree_recursive(tree, "", 0, 1, &paths, single_tree_cb,
-                                   &tree_ctx);
+               read_tree(the_repository, tree, &paths, single_tree_cb, &tree_ctx);

 
                if (tree_ctx.count != 1)
                        break;
 
                if (tree_ctx.count != 1)
                        break;


@@ -222,28 +198,29 @@ static void write_tree_link(const unsigned char *sha1, char *name,
        strbuf_setlen(fullpath, initial_length);
 }
 
        strbuf_setlen(fullpath, initial_length);
 }
 

-static int ls_item(const unsigned char *sha1, struct strbuf *base,
-               const char *pathname, unsigned mode, int stage, void *cbdata)
+static int ls_item(const struct object_id *oid, struct strbuf *base,
+               const char *pathname, unsigned mode, void *cbdata)

 {
        struct walk_tree_context *walk_tree_ctx = cbdata;
        char *name;
        struct strbuf fullpath = STRBUF_INIT;
 {
        struct walk_tree_context *walk_tree_ctx = cbdata;
        char *name;
        struct strbuf fullpath = STRBUF_INIT;

+       struct strbuf linkpath = STRBUF_INIT;

        struct strbuf class = STRBUF_INIT;
        enum object_type type;
        unsigned long size = 0;
        struct strbuf class = STRBUF_INIT;
        enum object_type type;
        unsigned long size = 0;

+       char *buf;

 
        name = xstrdup(pathname);
        strbuf_addf(&fullpath, "%s%s%s", ctx.qry.path ? ctx.qry.path : "",
                    ctx.qry.path ? "/" : "", name);
 
        if (!S_ISGITLINK(mode)) {
 
        name = xstrdup(pathname);
        strbuf_addf(&fullpath, "%s%s%s", ctx.qry.path ? ctx.qry.path : "",
                    ctx.qry.path ? "/" : "", name);
 
        if (!S_ISGITLINK(mode)) {

-               type = sha1_object_info(sha1, &size);
+               type = oid_object_info(the_repository, oid, &size);

                if (type == OBJ_BAD) {
                        htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>",
                              name,
                if (type == OBJ_BAD) {
                        htmlf("<tr><td colspan='3'>Bad object: %s %s</td></tr>",
                              name,

-                             sha1_to_hex(sha1));
-                       free(name);
-                       return 0;
+                             oid_to_hex(oid));
+                       goto cleanup;

                }
        }
 
                }
        }
 


@@ -251,9 +228,9 @@ static int ls_item(const unsigned char *sha1, struct strbuf *base,
        cgit_print_filemode(mode);
        html("</td><td>");
        if (S_ISGITLINK(mode)) {
        cgit_print_filemode(mode);
        html("</td><td>");
        if (S_ISGITLINK(mode)) {

-               cgit_submodule_link("ls-mod", fullpath.buf, sha1_to_hex(sha1));
+               cgit_submodule_link("ls-mod", fullpath.buf, oid_to_hex(oid));

        } else if (S_ISDIR(mode)) {
        } else if (S_ISDIR(mode)) {

-               write_tree_link(sha1, name, walk_tree_ctx->curr_rev,
+               write_tree_link(oid, name, walk_tree_ctx->curr_rev,

                                &fullpath);
        } else {
                char *ext = strrchr(name, '.');
                                &fullpath);
        } else {
                char *ext = strrchr(name, '.');


@@ -263,6 +240,21 @@ static int ls_item(const unsigned char *sha1, struct strbuf *base,
                cgit_tree_link(name, NULL, class.buf, ctx.qry.head,
                               walk_tree_ctx->curr_rev, fullpath.buf);
        }
                cgit_tree_link(name, NULL, class.buf, ctx.qry.head,
                               walk_tree_ctx->curr_rev, fullpath.buf);
        }

+       if (S_ISLNK(mode)) {
+               html(" -> ");
+               buf = repo_read_object_file(the_repository, oid, &type, &size);
+               if (!buf) {
+                       htmlf("Error reading object: %s", oid_to_hex(oid));
+                       goto cleanup;
+               }
+               strbuf_addbuf(&linkpath, &fullpath);
+               strbuf_addf(&linkpath, "/../%s", buf);
+               strbuf_normalize_path(&linkpath);
+               cgit_tree_link(buf, NULL, class.buf, ctx.qry.head,
+                       walk_tree_ctx->curr_rev, linkpath.buf);
+               free(buf);
+               strbuf_release(&linkpath);
+       }

        htmlf("</td><td class='ls-size'>%li</td>", size);
 
        html("<td>");
        htmlf("</td><td class='ls-size'>%li</td>", size);
 
        html("<td>");


@@ -275,7 +267,12 @@ static int ls_item(const unsigned char *sha1, struct strbuf *base,
        if (!S_ISGITLINK(mode))
                cgit_plain_link("plain", NULL, "button", ctx.qry.head,
                                walk_tree_ctx->curr_rev, fullpath.buf);
        if (!S_ISGITLINK(mode))
                cgit_plain_link("plain", NULL, "button", ctx.qry.head,
                                walk_tree_ctx->curr_rev, fullpath.buf);

+       if (!S_ISDIR(mode) && ctx.repo->enable_blame)
+               cgit_blame_link("blame", NULL, "button", ctx.qry.head,
+                               walk_tree_ctx->curr_rev, fullpath.buf);

        html("</td></tr>\n");
        html("</td></tr>\n");

+
+cleanup:

        free(name);
        strbuf_release(&fullpath);
        strbuf_release(&class);
        free(name);
        strbuf_release(&fullpath);
        strbuf_release(&class);


@@ -300,7 +297,7 @@ static void ls_tail(void)
        cgit_print_layout_end();
 }
 
        cgit_print_layout_end();
 }
 

-static void ls_tree(const struct object_id *oid, char *path, struct walk_tree_context *walk_tree_ctx)
+static void ls_tree(const struct object_id *oid, const char *path, struct walk_tree_context *walk_tree_ctx)

 {
        struct tree *tree;
        struct pathspec paths = {
 {
        struct tree *tree;
        struct pathspec paths = {


@@ -310,18 +307,18 @@ static void ls_tree(const struct object_id *oid, char *path, struct walk_tree_co
        tree = parse_tree_indirect(oid);
        if (!tree) {
                cgit_print_error_page(404, "Not found",
        tree = parse_tree_indirect(oid);
        if (!tree) {
                cgit_print_error_page(404, "Not found",

-                       "Not a tree object: %s", sha1_to_hex(oid->hash));
+                       "Not a tree object: %s", oid_to_hex(oid));

                return;
        }
 
        ls_head();
                return;
        }
 
        ls_head();

-       read_tree_recursive(tree, "", 0, 1, &paths, ls_item, walk_tree_ctx);
+       read_tree(the_repository, tree, &paths, ls_item, walk_tree_ctx);

        ls_tail();
 }
 
 
        ls_tail();
 }
 
 

-static int walk_tree(const unsigned char *sha1, struct strbuf *base,
-               const char *pathname, unsigned mode, int stage, void *cbdata)
+static int walk_tree(const struct object_id *oid, struct strbuf *base,
+               const char *pathname, unsigned mode, void *cbdata)

 {
        struct walk_tree_context *walk_tree_ctx = cbdata;
 
 {
        struct walk_tree_context *walk_tree_ctx = cbdata;
 


@@ -335,18 +332,18 @@ static int walk_tree(const unsigned char *sha1, struct strbuf *base,
 
                if (S_ISDIR(mode)) {
                        walk_tree_ctx->state = 1;
 
                if (S_ISDIR(mode)) {
                        walk_tree_ctx->state = 1;

-                       set_title_from_path(buffer.buf);
+                       cgit_set_title_from_path(buffer.buf);

                        strbuf_release(&buffer);
                        ls_head();
                        return READ_TREE_RECURSIVE;
                } else {
                        walk_tree_ctx->state = 2;
                        strbuf_release(&buffer);
                        ls_head();
                        return READ_TREE_RECURSIVE;
                } else {
                        walk_tree_ctx->state = 2;

-                       print_object(sha1, buffer.buf, pathname, walk_tree_ctx->curr_rev);
+                       print_object(oid, buffer.buf, pathname, walk_tree_ctx->curr_rev);

                        strbuf_release(&buffer);
                        return 0;
                }
        }
                        strbuf_release(&buffer);
                        return 0;
                }
        }

-       ls_item(sha1, base, pathname, mode, stage, walk_tree_ctx);
+       ls_item(oid, base, pathname, mode, walk_tree_ctx);

        return 0;
 }
 
        return 0;
 }
 


@@ -375,13 +372,13 @@ void cgit_print_tree(const char *rev, char *path)
        if (!rev)
                rev = ctx.qry.head;
 
        if (!rev)
                rev = ctx.qry.head;
 

-       if (get_oid(rev, &oid)) {
+       if (repo_get_oid(the_repository, rev, &oid)) {

                cgit_print_error_page(404, "Not found",
                        "Invalid revision name: %s", rev);
                return;
        }
                cgit_print_error_page(404, "Not found",
                        "Invalid revision name: %s", rev);
                return;
        }

-       commit = lookup_commit_reference(&oid);
-       if (!commit || parse_commit(commit)) {
+       commit = lookup_commit_reference(the_repository, &oid);
+       if (!commit || repo_parse_commit(the_repository, commit)) {

                cgit_print_error_page(404, "Not found",
                        "Invalid commit reference: %s", rev);
                return;
                cgit_print_error_page(404, "Not found",
                        "Invalid commit reference: %s", rev);
                return;


@@ -390,11 +387,12 @@ void cgit_print_tree(const char *rev, char *path)
        walk_tree_ctx.curr_rev = xstrdup(rev);
 
        if (path == NULL) {
        walk_tree_ctx.curr_rev = xstrdup(rev);
 
        if (path == NULL) {

-               ls_tree(&commit->tree->object.oid, NULL, &walk_tree_ctx);
+               ls_tree(get_commit_tree_oid(commit), NULL, &walk_tree_ctx);

                goto cleanup;
        }
 
                goto cleanup;
        }
 

-       read_tree_recursive(commit->tree, "", 0, 0, &paths, walk_tree, &walk_tree_ctx);
+       read_tree(the_repository, repo_get_commit_tree(the_repository, commit),
+                 &paths, walk_tree, &walk_tree_ctx);

        if (walk_tree_ctx.state == 1)
                ls_tail();
        else if (walk_tree_ctx.state == 2)
        if (walk_tree_ctx.state == 1)
                ls_tail();
        else if (walk_tree_ctx.state == 2)