From: Jonathan Dieter <jdieter@gmail.com>
Date: Wed, 25 Jul 2018 14:51:22 +0000 (+0100)
Subject: Rename VALIDATE_*_TRI to VALIDATE_*_INT
X-Git-Tag: archive/raspbian/1.1.9+ds1-1+rpi1~1^2~179
X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=9fcd916c6a9e266803bd7459147f41262e8200f5;p=zchunk.git

Rename VALIDATE_*_TRI to VALIDATE_*_INT

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

diff --git a/src/lib/comp/comp.c b/src/lib/comp/comp.c
index e7c5b4e..d5c7cb2 100644
--- a/src/lib/comp/comp.c
+++ b/src/lib/comp/comp.c
@@ -85,9 +85,9 @@ static int set_comp_type(zckCtx *zck, ssize_t type) {
 
 static size_t comp_read_from_dc(zckCtx *zck, zckComp *comp, char *dst,
                                 size_t dst_size) {
-    VALIDATE_TRI(zck);
-    _VALIDATE_TRI(comp);
-    _VALIDATE_TRI(dst);
+    VALIDATE_INT(zck);
+    _VALIDATE_INT(comp);
+    _VALIDATE_INT(dst);
 
     size_t dl_size = dst_size;
     if(dl_size > comp->dc_data_size - comp->dc_data_loc)
@@ -121,7 +121,7 @@ static int comp_add_to_data(zckCtx *zck, zckComp *comp, const char *src,
 }
 
 static ssize_t comp_end_dchunk(zckCtx *zck, int use_dict, size_t fd_size) {
-    VALIDATE_READ_TRI(zck);
+    VALIDATE_READ_INT(zck);
 
     ssize_t rb = zck->comp.end_dchunk(zck, &(zck->comp), use_dict, fd_size);
     if(validate_current_chunk(zck) < 1)
@@ -134,7 +134,7 @@ static ssize_t comp_end_dchunk(zckCtx *zck, int use_dict, size_t fd_size) {
 }
 
 static ssize_t comp_write(zckCtx *zck, const char *src, const size_t src_size) {
-    VALIDATE_WRITE_TRI(zck);
+    VALIDATE_WRITE_INT(zck);
 
     if(!zck->comp.started && !comp_init(zck))
         return -1;
@@ -328,7 +328,7 @@ int comp_add_to_dc(zckCtx *zck, zckComp *comp, const char *src,
 }
 
 ssize_t comp_read(zckCtx *zck, char *dst, size_t dst_size, int use_dict) {
-    VALIDATE_READ_TRI(zck);
+    VALIDATE_READ_INT(zck);
 
     if(!zck->comp.started) {
         set_error(zck, "Compression hasn't been initialized yet");
@@ -478,7 +478,7 @@ ssize_t PUBLIC zck_write(zckCtx *zck, const char *src, const size_t src_size) {
 }
 
 ssize_t PUBLIC zck_end_chunk(zckCtx *zck) {
-    VALIDATE_WRITE_TRI(zck);
+    VALIDATE_WRITE_INT(zck);
 
     if(!zck->comp.started && !comp_init(zck))
         return -1;
@@ -511,7 +511,7 @@ ssize_t PUBLIC zck_end_chunk(zckCtx *zck) {
 }
 
 ssize_t PUBLIC zck_read(zckCtx *zck, char *dst, size_t dst_size) {
-    VALIDATE_READ_TRI(zck);
+    VALIDATE_READ_INT(zck);
 
     return comp_read(zck, dst, dst_size, 1);
 }
diff --git a/src/lib/comp/zstd/zstd.c b/src/lib/comp/zstd/zstd.c
index db50c4d..7cfb50c 100644
--- a/src/lib/comp/zstd/zstd.c
+++ b/src/lib/comp/zstd/zstd.c
@@ -62,8 +62,8 @@ static int init(zckCtx *zck, zckComp *comp) {
 static ssize_t compress(zckCtx *zck, zckComp *comp, const char *src,
                         const size_t src_size, char **dst, size_t *dst_size,
                         int use_dict) {
-    VALIDATE_TRI(zck);
-    _VALIDATE_TRI(comp);
+    VALIDATE_INT(zck);
+    _VALIDATE_INT(comp);
 
     comp->dc_data = realloc(comp->dc_data, comp->dc_data_size + src_size);
     if(comp->dc_data == NULL) {
diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c
index 5daf381..29498b1 100644
--- a/src/lib/dl/dl.c
+++ b/src/lib/dl/dl.c
@@ -95,8 +95,8 @@ static int set_chunk_valid(zckDL *dl) {
 
 /* Write length or to end of current chunk, whichever comes first */
 static int dl_write(zckDL *dl, const char *at, size_t length) {
-    _VALIDATE_TRI(dl);
-    VALIDATE_TRI(dl->zck);
+    _VALIDATE_INT(dl);
+    VALIDATE_INT(dl->zck);
 
     int wb = 0;
     if(dl->write_in_chunk > 0) {
@@ -266,13 +266,13 @@ int PUBLIC zck_copy_chunks(zckCtx *src, zckCtx *tgt) {
 }
 
 ssize_t PUBLIC zck_dl_get_bytes_downloaded(zckDL *dl) {
-    _VALIDATE_TRI(dl);
+    _VALIDATE_INT(dl);
 
     return dl->dl;
 }
 
 ssize_t PUBLIC zck_dl_get_bytes_uploaded(zckDL *dl) {
-    _VALIDATE_TRI(dl);
+    _VALIDATE_INT(dl);
 
     return dl->ul;
 }
diff --git a/src/lib/dl/range.c b/src/lib/dl/range.c
index 3bcb4c8..d8b8b88 100644
--- a/src/lib/dl/range.c
+++ b/src/lib/dl/range.c
@@ -230,7 +230,7 @@ char PUBLIC *zck_get_range(size_t start, size_t end) {
 }
 
 int PUBLIC zck_get_range_count(zckRange *range) {
-    _VALIDATE_TRI(range);
+    _VALIDATE_INT(range);
 
     return range->count;
 }
diff --git a/src/lib/hash/hash.c b/src/lib/hash/hash.c
index ff0c964..b062588 100644
--- a/src/lib/hash/hash.c
+++ b/src/lib/hash/hash.c
@@ -479,25 +479,25 @@ const char PUBLIC *zck_hash_name_from_type(int hash_type) {
 }
 
 int PUBLIC zck_get_full_hash_type(zckCtx *zck) {
-    VALIDATE_TRI(zck);
+    VALIDATE_INT(zck);
 
     return zck->hash_type.type;
 }
 
 ssize_t PUBLIC zck_get_full_digest_size(zckCtx *zck) {
-    VALIDATE_TRI(zck);
+    VALIDATE_INT(zck);
 
     return zck->hash_type.digest_size;
 }
 
 int PUBLIC zck_get_chunk_hash_type(zckCtx *zck) {
-    VALIDATE_TRI(zck);
+    VALIDATE_INT(zck);
 
     return zck->index.hash_type;
 }
 
 ssize_t PUBLIC zck_get_chunk_digest_size(zckCtx *zck) {
-    VALIDATE_TRI(zck);
+    VALIDATE_INT(zck);
 
     return zck->index.digest_size;
 }
diff --git a/src/lib/header.c b/src/lib/header.c
index 1d74984..3fe9b8f 100644
--- a/src/lib/header.c
+++ b/src/lib/header.c
@@ -566,17 +566,17 @@ int PUBLIC zck_read_header(zckCtx *zck) {
 }
 
 ssize_t PUBLIC zck_get_header_length(zckCtx *zck) {
-    VALIDATE_TRI(zck);
+    VALIDATE_INT(zck);
     return zck->lead_size + zck->header_length;
 }
 
 ssize_t PUBLIC zck_get_lead_length(zckCtx *zck) {
-    VALIDATE_TRI(zck);
+    VALIDATE_INT(zck);
     return zck->lead_size;
 }
 
 ssize_t PUBLIC zck_get_data_length(zckCtx *zck) {
-    VALIDATE_TRI(zck);
+    VALIDATE_INT(zck);
     zckChunk *idx = zck->index.first;
     while(idx->next != NULL)
         idx = idx->next;
@@ -584,6 +584,6 @@ ssize_t PUBLIC zck_get_data_length(zckCtx *zck) {
 }
 
 ssize_t PUBLIC zck_get_length(zckCtx *zck) {
-    VALIDATE_TRI(zck);
+    VALIDATE_INT(zck);
     return zck_get_header_length(zck) + zck_get_data_length(zck);
 }
diff --git a/src/lib/index/index_read.c b/src/lib/index/index_read.c
index 1cadd48..5a80dca 100644
--- a/src/lib/index/index_read.c
+++ b/src/lib/index/index_read.c
@@ -121,7 +121,7 @@ int index_read(zckCtx *zck, char *data, size_t size, size_t max_length) {
 }
 
 ssize_t PUBLIC zck_get_chunk_count(zckCtx *zck) {
-    VALIDATE_TRI(zck);
+    VALIDATE_INT(zck);
 
     return zck->index.count;
 }
@@ -139,10 +139,10 @@ zckChunk PUBLIC *zck_get_next_chunk(zckChunk *idx) {
 }
 
 ssize_t PUBLIC zck_get_chunk_start(zckChunk *idx) {
-    _VALIDATE_TRI(idx);
+    _VALIDATE_INT(idx);
 
     if(idx->zck) {
-        VALIDATE_TRI(idx->zck);
+        VALIDATE_INT(idx->zck);
         return idx->start + zck_get_header_length(idx->zck);
     } else {
         return idx->start;
@@ -150,19 +150,19 @@ ssize_t PUBLIC zck_get_chunk_start(zckChunk *idx) {
 }
 
 ssize_t PUBLIC zck_get_chunk_size(zckChunk *idx) {
-    _VALIDATE_TRI(idx);
+    _VALIDATE_INT(idx);
 
     return idx->length;
 }
 
 ssize_t PUBLIC zck_get_chunk_comp_size(zckChunk *idx) {
-    _VALIDATE_TRI(idx);
+    _VALIDATE_INT(idx);
 
     return idx->comp_length;
 }
 
 int PUBLIC zck_get_chunk_valid(zckChunk *idx) {
-    _VALIDATE_TRI(idx);
+    _VALIDATE_INT(idx);
 
     return idx->valid;
 }
@@ -179,7 +179,7 @@ int PUBLIC zck_compare_chunk_digest(zckChunk *a, zckChunk *b) {
 }
 
 int PUBLIC zck_missing_chunks(zckCtx *zck) {
-    VALIDATE_READ_TRI(zck);
+    VALIDATE_READ_INT(zck);
 
     int missing = 0;
     for(zckChunk *idx = zck->index.first; idx; idx=idx->next)
@@ -189,7 +189,7 @@ int PUBLIC zck_missing_chunks(zckCtx *zck) {
 }
 
 int PUBLIC zck_failed_chunks(zckCtx *zck) {
-    VALIDATE_READ_TRI(zck);
+    VALIDATE_READ_INT(zck);
 
     int failed = 0;
     for(zckChunk *idx = zck->index.first; idx; idx=idx->next)
diff --git a/src/lib/io.c b/src/lib/io.c
index f7c79f9..651521e 100644
--- a/src/lib/io.c
+++ b/src/lib/io.c
@@ -34,7 +34,7 @@
 #include "zck_private.h"
 
 ssize_t read_data(zckCtx *zck, char *data, size_t length) {
-    VALIDATE_READ_TRI(zck);
+    VALIDATE_READ_INT(zck);
 
     if(length == 0)
         return 0;
@@ -51,7 +51,7 @@ ssize_t read_data(zckCtx *zck, char *data, size_t length) {
 }
 
 int write_data(zckCtx *zck, int fd, const char *data, size_t length) {
-    VALIDATE_WRITE_TRI(zck);
+    VALIDATE_WRITE_INT(zck);
 
     if(length == 0)
         return True;
@@ -71,7 +71,7 @@ int write_data(zckCtx *zck, int fd, const char *data, size_t length) {
 }
 
 int seek_data(zckCtx *zck, off_t offset, int whence) {
-    VALIDATE_TRI(zck);
+    VALIDATE_INT(zck);
 
     if(lseek(zck->fd, offset, whence) == -1) {
         char *wh_str = NULL;
diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h
index 3e3fc33..7073162 100644
--- a/src/lib/zck_private.h
+++ b/src/lib/zck_private.h
@@ -30,7 +30,7 @@
                                         "Object not initialized"); \
                                 return False; \
                             }
-#define _VALIDATE_TRI(f)    if(!f) { \
+#define _VALIDATE_INT(f)    if(!f) { \
                                 zck_log(ZCK_LOG_NONE, \
                                         "Object not initialized"); \
                                 return -1; \
@@ -42,7 +42,7 @@
                             }
 #define VALIDATE_BOOL(f)    _VALIDATE_BOOL(f) \
                             if((f)->error_state > 0) return False;
-#define VALIDATE_TRI(f)     _VALIDATE_TRI(f) \
+#define VALIDATE_INT(f)     _VALIDATE_INT(f) \
                             if((f)->error_state > 0) return -1;
 #define VALIDATE_CHAR(f)    _VALIDATE_CHAR(f) \
                             if((f)->error_state > 0) return NULL;
@@ -53,7 +53,7 @@
                                         "zckCtx not opened for reading"); \
                                     return False; \
                                 }
-#define VALIDATE_READ_TRI(f)    VALIDATE_TRI(f); \
+#define VALIDATE_READ_INT(f)    VALIDATE_INT(f); \
                                 if(f->mode != ZCK_MODE_READ) { \
                                     set_error(f, \
                                         "zckCtx not opened for reading"); \
@@ -72,7 +72,7 @@
                                         "zckCtx not opened for writing"); \
                                     return False; \
                                 }
-#define VALIDATE_WRITE_TRI(f)   VALIDATE_TRI(f); \
+#define VALIDATE_WRITE_INT(f)   VALIDATE_INT(f); \
                                 if(f->mode != ZCK_MODE_WRITE) { \
                                     set_error(f, \
                                         "zckCtx not opened for writing"); \