Rename _VALIDATE_* to ALLOCD_*

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

diff --git a/src/lib/comp/comp.c b/src/lib/comp/comp.c
index d5c7cb275977bb6512d8810e8a9715053ba6a1dd..f053c5c93fdd71f0040387f169316046ae812ef7 100644 (file)
--- a/src/lib/comp/comp.c
+++ b/src/lib/comp/comp.c
@@ -86,8 +86,8 @@ 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_INT(zck);
-    _VALIDATE_INT(comp);
-    _VALIDATE_INT(dst);
+    ALLOCD_INT(comp);
+    ALLOCD_INT(dst);
 
     size_t dl_size = dst_size;
     if(dl_size > comp->dc_data_size - comp->dc_data_loc)
@@ -103,8 +103,8 @@ static size_t comp_read_from_dc(zckCtx *zck, zckComp *comp, char *dst,
 static int comp_add_to_data(zckCtx *zck, zckComp *comp, const char *src,
                             size_t src_size) {
     VALIDATE_BOOL(zck);
-    _VALIDATE_BOOL(comp);
-    _VALIDATE_BOOL(src);
+    ALLOCD_BOOL(comp);
+    ALLOCD_BOOL(src);
 
     comp->data = realloc(comp->data, comp->data_size + src_size);
     if(comp->data == NULL) {
@@ -223,7 +223,7 @@ int comp_init(zckCtx *zck) {
 }
 
 int comp_reset(zckCtx *zck) {
-    _VALIDATE_BOOL(zck);
+    ALLOCD_BOOL(zck);
 
     zck->comp.started = 0;
     if(zck->comp.dc_data) {
@@ -238,7 +238,7 @@ int comp_reset(zckCtx *zck) {
 }
 
 int comp_close(zckCtx *zck) {
-    _VALIDATE_BOOL(zck);
+    ALLOCD_BOOL(zck);
 
     zck_log(ZCK_LOG_DEBUG, "Closing compression");
     if(zck->comp.data) {
@@ -299,8 +299,8 @@ int comp_soption(zckCtx *zck, zck_soption option, const void *value,
 int comp_add_to_dc(zckCtx *zck, zckComp *comp, const char *src,
                    size_t src_size) {
     VALIDATE_BOOL(zck);
-    _VALIDATE_BOOL(comp);
-    _VALIDATE_BOOL(src);
+    ALLOCD_BOOL(comp);
+    ALLOCD_BOOL(src);
 
     /* Get rid of any already read data and allocate space for new data */
     char *temp = zmalloc(comp->dc_data_size - comp->dc_data_loc + src_size);

diff --git a/src/lib/comp/zstd/zstd.c b/src/lib/comp/zstd/zstd.c
index 7cfb50cf21a5a26edffae4e01f4188e95746dd7e..301dc04f387339f92ecc9207b72965a9d091f03c 100644 (file)
--- a/src/lib/comp/zstd/zstd.c
+++ b/src/lib/comp/zstd/zstd.c
@@ -34,7 +34,7 @@
 
 static int init(zckCtx *zck, zckComp *comp) {
     VALIDATE_BOOL(zck);
-    _VALIDATE_BOOL(comp);
+    ALLOCD_BOOL(comp);
 
     comp->cctx = ZSTD_createCCtx();
     comp->dctx = ZSTD_createDCtx();
@@ -63,7 +63,7 @@ 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_INT(zck);
-    _VALIDATE_INT(comp);
+    ALLOCD_INT(comp);
 
     comp->dc_data = realloc(comp->dc_data, comp->dc_data_size + src_size);
     if(comp->dc_data == NULL) {
@@ -81,7 +81,7 @@ static ssize_t compress(zckCtx *zck, zckComp *comp, const char *src,
 static int end_cchunk(zckCtx *zck, zckComp *comp, char **dst, size_t *dst_size,
                       int use_dict) {
     VALIDATE_BOOL(zck);
-    _VALIDATE_BOOL(comp);
+    ALLOCD_BOOL(comp);
 
     size_t max_size = ZSTD_compressBound(comp->dc_data_size);
     if(ZSTD_isError(max_size)) {
@@ -118,7 +118,7 @@ static int end_cchunk(zckCtx *zck, zckComp *comp, char **dst, size_t *dst_size,
 
 static int decompress(zckCtx *zck, zckComp *comp, const int use_dict) {
     VALIDATE_BOOL(zck);
-    _VALIDATE_BOOL(comp);
+    ALLOCD_BOOL(comp);
 
     return True;
 }
@@ -126,7 +126,7 @@ static int decompress(zckCtx *zck, zckComp *comp, const int use_dict) {
 static int end_dchunk(zckCtx *zck, zckComp *comp, const int use_dict,
                       const size_t fd_size) {
     VALIDATE_BOOL(zck);
-    _VALIDATE_BOOL(comp);
+    ALLOCD_BOOL(comp);
 
     char *src = comp->data;
     size_t src_size = comp->data_size;

diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c
index a9bd88ec2a14e43ea7a6f74b3fb2d4ce85041c36..66f708cc3fbdfb3ad82f13ae1ee96eb146ee7b6e 100644 (file)
--- a/src/lib/dl/dl.c
+++ b/src/lib/dl/dl.c
@@ -76,7 +76,7 @@ static int zero_chunk(zckCtx *tgt, zckChunk *tgt_idx) {
 
 /* Check whether last downloaded chunk is valid and zero it out if it isn't */
 static int set_chunk_valid(zckDL *dl) {
-    _VALIDATE_BOOL(dl);
+    ALLOCD_BOOL(dl);
     VALIDATE_BOOL(dl->zck);
 
     int retval = validate_chunk(dl->zck, dl->tgt_check, ZCK_LOG_WARNING,
@@ -95,7 +95,7 @@ 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_INT(dl);
+    ALLOCD_INT(dl);
     VALIDATE_INT(dl->zck);
 
     int wb = 0;
@@ -167,7 +167,7 @@ static int write_and_verify_chunk(zckCtx *src, zckCtx *tgt,
 
 /* Split current read into the appropriate chunks and write appropriately */
 int dl_write_range(zckDL *dl, const char *at, size_t length) {
-    _VALIDATE_BOOL(dl);
+    ALLOCD_BOOL(dl);
     VALIDATE_BOOL(dl->zck);
 
     if(dl->range == NULL) {
@@ -266,13 +266,13 @@ int PUBLIC zck_copy_chunks(zckCtx *src, zckCtx *tgt) {
 }
 
 ssize_t PUBLIC zck_dl_get_bytes_downloaded(zckDL *dl) {
-    _VALIDATE_INT(dl);
+    ALLOCD_INT(dl);
 
     return dl->dl;
 }
 
 ssize_t PUBLIC zck_dl_get_bytes_uploaded(zckDL *dl) {
-    _VALIDATE_INT(dl);
+    ALLOCD_INT(dl);
 
     return dl->ul;
 }
@@ -327,53 +327,53 @@ void PUBLIC zck_dl_free(zckDL **dl) {
 }
 
 zckCtx PUBLIC *zck_dl_get_zck(zckDL *dl) {
-    _VALIDATE_PTR(dl);
+    ALLOCD_PTR(dl);
 
     return dl->zck;
 }
 
 int PUBLIC zck_dl_set_zck(zckDL *dl, zckCtx *zck) {
-    _VALIDATE_BOOL(dl);
+    ALLOCD_BOOL(dl);
 
     dl->zck = zck;
     return True;
 }
 int PUBLIC zck_dl_set_range(zckDL *dl, zckRange *range) {
-    _VALIDATE_BOOL(dl);
+    ALLOCD_BOOL(dl);
 
     dl->range = range;
     return True;
 }
 
 zckRange PUBLIC *zck_dl_get_range(zckDL *dl) {
-    _VALIDATE_PTR(dl);
+    ALLOCD_PTR(dl);
 
     return dl->range;
 }
 
 int PUBLIC zck_dl_set_header_cb(zckDL *dl, zck_wcb func) {
-    _VALIDATE_BOOL(dl);
+    ALLOCD_BOOL(dl);
 
     dl->header_cb = func;
     return True;
 }
 
 int PUBLIC zck_dl_set_header_data(zckDL *dl, void *data) {
-    _VALIDATE_BOOL(dl);
+    ALLOCD_BOOL(dl);
 
     dl->header_data = data;
     return True;
 }
 
 int PUBLIC zck_dl_set_write_cb(zckDL *dl, zck_wcb func) {
-    _VALIDATE_BOOL(dl);
+    ALLOCD_BOOL(dl);
 
     dl->write_cb = func;
     return True;
 }
 
 int PUBLIC zck_dl_set_write_data(zckDL *dl, void *data) {
-    _VALIDATE_BOOL(dl);
+    ALLOCD_BOOL(dl);
 
     dl->write_data = data;
     return True;
@@ -384,7 +384,7 @@ int PUBLIC zck_dl_set_write_data(zckDL *dl, void *data) {
  *******************************************************************/
 
 size_t PUBLIC zck_header_cb(char *b, size_t l, size_t c, void *dl_v) {
-    _VALIDATE_BOOL(dl_v);
+    ALLOCD_BOOL(dl_v);
     zckDL *dl = (zckDL*)dl_v;
 
     if(multipart_get_boundary(dl, b, c*l) == 0)
@@ -396,7 +396,7 @@ size_t PUBLIC zck_header_cb(char *b, size_t l, size_t c, void *dl_v) {
 }
 
 size_t PUBLIC zck_write_zck_header_cb(void *ptr, size_t l, size_t c, void *dl_v) {
-    _VALIDATE_BOOL(dl_v);
+    ALLOCD_BOOL(dl_v);
     zckDL *dl = (zckDL*)dl_v;
 
     size_t wb = 0;
@@ -410,7 +410,7 @@ size_t PUBLIC zck_write_zck_header_cb(void *ptr, size_t l, size_t c, void *dl_v)
 }
 
 size_t PUBLIC zck_write_chunk_cb(void *ptr, size_t l, size_t c, void *dl_v) {
-    _VALIDATE_BOOL(dl_v);
+    ALLOCD_BOOL(dl_v);
     zckDL *dl = (zckDL*)dl_v;
 
     size_t wb = 0;

diff --git a/src/lib/dl/multipart.c b/src/lib/dl/multipart.c
index fef9e07d41c9d67853e6ad01bbda1531b1e6ba38..b0dcc0dea199427b271327dd677258d66e97699d 100644 (file)
--- a/src/lib/dl/multipart.c
+++ b/src/lib/dl/multipart.c
@@ -70,7 +70,7 @@ static int create_regex(zckCtx *zck, regex_t *reg, const char *regex) {
 }
 
 static int gen_regex(zckDL *dl) {
-    _VALIDATE_BOOL(dl);
+    ALLOCD_BOOL(dl);
     VALIDATE_BOOL(dl->zck);
 
     char *next = "\r\n--%s\r\ncontent-type:.*\r\n" \
@@ -106,7 +106,7 @@ void reset_mp(zckMP *mp) {
 }
 
 size_t multipart_extract(zckDL *dl, char *b, size_t l) {
-    _VALIDATE_BOOL(dl);
+    ALLOCD_BOOL(dl);
     VALIDATE_BOOL(dl->zck);
 
     if(dl == NULL || dl->mp == NULL)
@@ -215,7 +215,7 @@ end:
 }
 
 size_t multipart_get_boundary(zckDL *dl, char *b, size_t size) {
-    _VALIDATE_BOOL(dl);
+    ALLOCD_BOOL(dl);
     VALIDATE_BOOL(dl->zck);
 
     if(dl == NULL)

diff --git a/src/lib/dl/range.c b/src/lib/dl/range.c
index 9927d72507e336439752ec375891f59bb82e6740..027a1ac921e4381d41f45725a1f181f91b6ec94a 100644 (file)
--- 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_INT(range);
+    ALLOCD_INT(range);
 
     return range->count;
 }

diff --git a/src/lib/index/index_create.c b/src/lib/index/index_create.c
index 0a2bd3c33fe31a5fc7e968e9d24d7e228048f988..3923b01eee98e578da4e4819aebb0b4b955070dc 100644 (file)
--- a/src/lib/index/index_create.c
+++ b/src/lib/index/index_create.c
@@ -49,8 +49,8 @@ static int create_chunk(zckCtx *zck) {
 static int finish_chunk(zckIndex *index, zckChunk *item, char *digest,
                         int valid, zckCtx *zck) {
     VALIDATE_BOOL(zck);
-    _VALIDATE_BOOL(index);
-    _VALIDATE_BOOL(item);
+    ALLOCD_BOOL(index);
+    ALLOCD_BOOL(item);
 
     item->digest = zmalloc(index->digest_size);
     if(item->digest == NULL) {

diff --git a/src/lib/index/index_read.c b/src/lib/index/index_read.c
index 9625b577f01347bef9eb30b1e7d37691a14acdab..8af45a149bbc2f08ba5622591a911224f1cf7d5e 100644 (file)
--- a/src/lib/index/index_read.c
+++ b/src/lib/index/index_read.c
@@ -133,13 +133,13 @@ zckChunk PUBLIC *zck_get_first_chunk(zckCtx *zck) {
 }
 
 zckChunk PUBLIC *zck_get_next_chunk(zckChunk *idx) {
-    _VALIDATE_PTR(idx);
+    ALLOCD_PTR(idx);
 
     return idx->next;
 }
 
 ssize_t PUBLIC zck_get_chunk_start(zckChunk *idx) {
-    _VALIDATE_INT(idx);
+    ALLOCD_INT(idx);
 
     if(idx->zck) {
         VALIDATE_INT(idx->zck);
@@ -150,26 +150,26 @@ ssize_t PUBLIC zck_get_chunk_start(zckChunk *idx) {
 }
 
 ssize_t PUBLIC zck_get_chunk_size(zckChunk *idx) {
-    _VALIDATE_INT(idx);
+    ALLOCD_INT(idx);
 
     return idx->length;
 }
 
 ssize_t PUBLIC zck_get_chunk_comp_size(zckChunk *idx) {
-    _VALIDATE_INT(idx);
+    ALLOCD_INT(idx);
 
     return idx->comp_length;
 }
 
 int PUBLIC zck_get_chunk_valid(zckChunk *idx) {
-    _VALIDATE_INT(idx);
+    ALLOCD_INT(idx);
 
     return idx->valid;
 }
 
 int PUBLIC zck_compare_chunk_digest(zckChunk *a, zckChunk *b) {
-    _VALIDATE_BOOL(a);
-    _VALIDATE_BOOL(b);
+    ALLOCD_BOOL(a);
+    ALLOCD_BOOL(b);
 
     if(a->digest_size != b->digest_size)
         return False;

diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h
index 5dbeedce802a4fbfc15a1c47917e84e8d0bb7f35..4ce806d49864a81a534b48c514c4280f149e93e0 100644 (file)
--- a/src/lib/zck_private.h
+++ b/src/lib/zck_private.h
@@ -25,26 +25,26 @@
 #define set_error(zck, ...) set_error_wf(zck, 0, __func__, __VA_ARGS__)
 #define set_fatal_error(zck, ...) set_error_wf(zck, 1, __func__, __VA_ARGS__)
 
-#define _VALIDATE_BOOL(f)   if(!f) { \
+#define ALLOCD_BOOL(f)      if(!f) { \
                                 zck_log(ZCK_LOG_NONE, \
                                         "Object not initialized"); \
                                 return False; \
                             }
-#define _VALIDATE_INT(f)    if(!f) { \
+#define ALLOCD_INT(f)       if(!f) { \
                                 zck_log(ZCK_LOG_NONE, \
                                         "Object not initialized"); \
                                 return -1; \
                             }
-#define _VALIDATE_PTR(f)    if(!f) { \
+#define ALLOCD_PTR(f)       if(!f) { \
                                 zck_log(ZCK_LOG_NONE, \
                                         "Object not initialized"); \
                                 return NULL; \
                             }
-#define VALIDATE_BOOL(f)    _VALIDATE_BOOL(f) \
+#define VALIDATE_BOOL(f)    ALLOCD_BOOL(f) \
                             if((f)->error_state > 0) return False;
-#define VALIDATE_INT(f)     _VALIDATE_INT(f) \
+#define VALIDATE_INT(f)     ALLOCD_INT(f) \
                             if((f)->error_state > 0) return -1;
-#define VALIDATE_PTR(f)     _VALIDATE_PTR(f) \
+#define VALIDATE_PTR(f)     ALLOCD_PTR(f) \
                             if((f)->error_state > 0) return NULL;
 
 #define VALIDATE_READ_BOOL(f)   VALIDATE_BOOL(f); \