Make functions that aren't used outside of file static and remove unused

functions

Signed-off-by: Jonathan Dieter <jdieter@gmail.com>

diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c
index 39f84665e3367e45c79dbeceaa642d8d120fd257..e5852f7b6671947a1c29af35793ed4dbb77f6933 100644 (file)
--- a/src/lib/dl/dl.c
+++ b/src/lib/dl/dl.c
@@ -41,7 +41,7 @@
                         }
 
 /* Free zckDL header regex used for downloading ranges */
-void clear_dl_regex(zckDL *dl) {
+static void clear_dl_regex(zckDL *dl) {
     if(dl == NULL || dl->priv == NULL)
         return;
 
@@ -183,8 +183,9 @@ int dl_write_range(zckDL *dl, const char *at, size_t length) {
 }
 
 /* Copy chunk identified by src_idx into location specified by tgt_idx */
-int write_and_verify_chunk(zckCtx *src, zckCtx *tgt, zckIndexItem *src_idx,
-                           zckIndexItem *tgt_idx) {
+static int write_and_verify_chunk(zckCtx *src, zckCtx *tgt,
+                                  zckIndexItem *src_idx,
+                                  zckIndexItem *tgt_idx) {
     static char buf[BUF_SIZE] = {0};
 
     size_t to_read = src_idx->comp_length;

diff --git a/src/lib/dl/range.c b/src/lib/dl/range.c
index 1ecd685a74156db0a722989a1c55d106f553b8be..fcdacd37272d434b54fbc904a75547c3439c071d 100644 (file)
--- a/src/lib/dl/range.c
+++ b/src/lib/dl/range.c
@@ -34,21 +34,10 @@
 
 #include "zck_private.h"
 
-void PUBLIC zck_range_free(zckRange **info) {
-    zckRangeItem *next = (*info)->first;
-    while(next) {
-        zckRangeItem *tmp = next;
-        next = next->next;
-        free(tmp);
-    }
-    index_clean(&((*info)->index));
-    free(*info);
-    *info = NULL;
-}
-
-zckRangeItem *range_insert_new(zckRangeItem *prev, zckRangeItem *next, uint64_t start,
-                               uint64_t end, zckRange *info,
-                               zckIndexItem *idx, int add_index) {
+static zckRangeItem *range_insert_new(zckRangeItem *prev, zckRangeItem *next,
+                                      uint64_t start, uint64_t end,
+                                      zckRange *info, zckIndexItem *idx,
+                                      int add_index) {
     zckRangeItem *new = zmalloc(sizeof(zckRangeItem));
     if(!new) {
         zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
@@ -74,7 +63,7 @@ zckRangeItem *range_insert_new(zckRangeItem *prev, zckRangeItem *next, uint64_t
     return new;
 }
 
-void range_remove(zckRangeItem *range) {
+static void range_remove(zckRangeItem *range) {
     if(range->prev)
         range->prev->next = range->next;
     if(range->next)
@@ -82,7 +71,7 @@ void range_remove(zckRangeItem *range) {
     free(range);
 }
 
-void range_merge_combined(zckRange *info) {
+static void range_merge_combined(zckRange *info) {
     if(!info) {
         zck_log(ZCK_LOG_ERROR, "zckRange not allocated\n");
         return;
@@ -99,7 +88,7 @@ void range_merge_combined(zckRange *info) {
     }
 }
 
-int range_add(zckRange *info, zckIndexItem *idx, zckCtx *zck) {
+static int range_add(zckRange *info, zckIndexItem *idx, zckCtx *zck) {
     if(info == NULL || idx == NULL) {
         zck_log(ZCK_LOG_ERROR, "zckRange or zckIndexItem not allocated\n");
         return False;
@@ -150,6 +139,18 @@ int range_add(zckRange *info, zckIndexItem *idx, zckCtx *zck) {
     return True;
 }
 
+void PUBLIC zck_range_free(zckRange **info) {
+    zckRangeItem *next = (*info)->first;
+    while(next) {
+        zckRangeItem *tmp = next;
+        next = next->next;
+        free(tmp);
+    }
+    index_clean(&((*info)->index));
+    free(*info);
+    *info = NULL;
+}
+
 char PUBLIC *zck_get_range_char(zckRange *range) {
     int buf_size=BUF_SIZE;
     char *output=malloc(buf_size);

diff --git a/src/lib/index/index_common.c b/src/lib/index/index_common.c
index 59b105f2a39fad7e196853ccda97a0befa20383d..9f49439e34f56d12f91f94d2ae615688394b97a9 100644 (file)
--- a/src/lib/index/index_common.c
+++ b/src/lib/index/index_common.c
@@ -31,19 +31,7 @@
 
 #include "zck_private.h"
 
-zckIndexItem *get_index_of_loc(zckIndex *index, size_t loc) {
-    zckIndexItem *idx = index->first;
-    while(idx != NULL) {
-        if(loc >= idx->start && loc < idx->start + idx->comp_length)
-            return idx;
-        idx = idx->next;
-    }
-    zck_log(ZCK_LOG_ERROR, "Unable to find index that contains position %lu\n",
-            loc);
-    return NULL;
-}
-
-void index_free_item(zckIndexItem **item) {
+static void index_free_item(zckIndexItem **item) {
     if(*item == NULL)
         return;
 

diff --git a/src/lib/index/index_create.c b/src/lib/index/index_create.c
index ef8017942b869440797f5245450bddd71322ba5a..75a17de979e0c4726616239046cc5c1a332a678d 100644 (file)
--- a/src/lib/index/index_create.c
+++ b/src/lib/index/index_create.c
@@ -36,6 +36,51 @@
                             return False; \
                         }
 
+static int create_chunk(zckCtx *zck) {
+    VALIDATE(zck);
+
+    clear_work_index(zck);
+    zck->work_index_item = zmalloc(sizeof(zckIndexItem));
+    if(zck->work_index_item == NULL) {
+        zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
+                sizeof(zckIndexItem));
+        return False;
+    }
+    if(!hash_init(&(zck->work_index_hash), &(zck->chunk_hash_type)))
+        return False;
+    return True;
+}
+
+static int finish_chunk(zckIndex *index, zckIndexItem *item, char *digest,
+                        int valid) {
+    VALIDATE(index);
+    VALIDATE(item);
+
+    item->digest = zmalloc(index->digest_size);
+    if(item->digest == NULL) {
+        zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
+                index->digest_size);
+        return False;
+    }
+    if(digest) {
+        memcpy(item->digest, digest, index->digest_size);
+        item->digest_size = index->digest_size;
+    }
+    item->start = index->length;
+    item->valid = valid;
+    if(index->first == NULL) {
+        index->first = item;
+    } else {
+        zckIndexItem *tmp = index->first;
+        while(tmp->next)
+            tmp = tmp->next;
+        tmp->next = item;
+    }
+    index->count += 1;
+    index->length += item->comp_length;
+    return True;
+}
+
 int index_create(zckCtx *zck) {
     VALIDATE(zck);
 
@@ -92,36 +137,6 @@ int index_create(zckCtx *zck) {
     return True;
 }
 
-static int finish_chunk(zckIndex *index, zckIndexItem *item, char *digest,
-                        int valid) {
-    VALIDATE(index);
-    VALIDATE(item);
-
-    item->digest = zmalloc(index->digest_size);
-    if(item->digest == NULL) {
-        zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
-                index->digest_size);
-        return False;
-    }
-    if(digest) {
-        memcpy(item->digest, digest, index->digest_size);
-        item->digest_size = index->digest_size;
-    }
-    item->start = index->length;
-    item->valid = valid;
-    if(index->first == NULL) {
-        index->first = item;
-    } else {
-        zckIndexItem *tmp = index->first;
-        while(tmp->next)
-            tmp = tmp->next;
-        tmp->next = item;
-    }
-    index->count += 1;
-    index->length += item->comp_length;
-    return True;
-}
-
 int index_new_chunk(zckIndex *index, char *digest, int digest_size,
                         size_t comp_size, size_t orig_size, int finished) {
     if(index == NULL) {
@@ -144,26 +159,11 @@ int index_new_chunk(zckIndex *index, char *digest, int digest_size,
     return finish_chunk(index, idx, digest, finished);
 }
 
-int index_create_chunk(zckCtx *zck) {
-    VALIDATE(zck);
-
-    clear_work_index(zck);
-    zck->work_index_item = zmalloc(sizeof(zckIndexItem));
-    if(zck->work_index_item == NULL) {
-        zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
-                sizeof(zckIndexItem));
-        return False;
-    }
-    if(!hash_init(&(zck->work_index_hash), &(zck->chunk_hash_type)))
-        return False;
-    return True;
-}
-
 int index_add_to_chunk(zckCtx *zck, char *data, size_t comp_size,
                            size_t orig_size) {
     VALIDATE(zck);
 
-    if(zck->work_index_item == NULL && !index_create_chunk(zck))
+    if(zck->work_index_item == NULL && !create_chunk(zck))
         return False;
 
     zck->work_index_item->length += orig_size;
@@ -182,7 +182,7 @@ int index_add_to_chunk(zckCtx *zck, char *data, size_t comp_size,
 int index_finish_chunk(zckCtx *zck) {
     VALIDATE(zck);
 
-    if(zck->work_index_item == NULL && !index_create_chunk(zck))
+    if(zck->work_index_item == NULL && !create_chunk(zck))
         return False;
 
     char *digest = NULL;

diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h
index d252c3414a0a1308313dec0cb240520bcad0daa5..190b851a2eeeb9cba57a0838505488c721bf9d86 100644 (file)
--- a/src/lib/zck_private.h
+++ b/src/lib/zck_private.h
@@ -208,12 +208,9 @@ int index_finish_chunk(zckCtx *zck)
     __attribute__ ((warn_unused_result));
 void index_clean(zckIndex *index);
 void index_free(zckCtx *zck);
-void index_free_item(zckIndexItem **item);
 void clear_work_index(zckCtx *zck);
 int write_index(zckCtx *zck)
     __attribute__ ((warn_unused_result));
-zckIndexItem *get_index_of_loc(zckIndex *index, size_t loc)
-    __attribute__ ((warn_unused_result));
 
 
 /* io.c */
@@ -272,8 +269,6 @@ int comp_soption(zckCtx *zck, zck_soption option, const void *value,
 /* dl/range.c */
 char *range_get_char(zckRangeItem **range, int max_ranges)
     __attribute__ ((warn_unused_result));
-int range_add(zckRange *info, zckIndexItem *idx, zckCtx *zck)
-    __attribute__ ((warn_unused_result));
 
 /* dl/multipart.c */
 size_t multipart_extract(zckDL *dl, char *b, size_t l)