Rename HDassert() to assert() (#3191)

* Change HDassert to assert

* Fix bin/make_err

1 files changed, 50 insertions, 50 deletions

diff --git a/src/H5FDmirror.c b/src/H5FDmirror.c
index 4df0d43..25992e8 100644
--- a/src/H5FDmirror.c
+++ b/src/H5FDmirror.c
@@ -282,7 +282,7 @@ H5FD__mirror_xmit_decode_uint16(uint16_t *out, const unsigned char *_buf)
 
     LOG_OP_CALL(__func__);
 
-    HDassert(_buf && out);
+    assert(_buf && out);
 
     H5MM_memcpy(&n, _buf, sizeof(n));
     *out = (uint16_t)ntohs(n);
@@ -310,7 +310,7 @@ H5FD__mirror_xmit_decode_uint32(uint32_t *out, const unsigned char *_buf)
 
     LOG_OP_CALL(__func__);
 
-    HDassert(_buf && out);
+    assert(_buf && out);
 
     H5MM_memcpy(&n, _buf, sizeof(n));
     *out = (uint32_t)ntohl(n);
@@ -369,7 +369,7 @@ H5FD__mirror_xmit_decode_uint64(uint64_t *out, const unsigned char *_buf)
 
     LOG_OP_CALL(__func__);
 
-    HDassert(_buf && out);
+    assert(_buf && out);
 
     H5MM_memcpy(&n, _buf, sizeof(n));
     if (TRUE == is_host_little_endian())
@@ -396,7 +396,7 @@ H5FD__mirror_xmit_decode_uint8(uint8_t *out, const unsigned char *_buf)
 {
     LOG_OP_CALL(__func__);
 
-    HDassert(_buf && out);
+    assert(_buf && out);
 
     H5MM_memcpy(out, _buf, sizeof(uint8_t));
 
@@ -422,7 +422,7 @@ H5FD__mirror_xmit_encode_uint16(unsigned char *_dest, uint16_t v)
 
     LOG_OP_CALL(__func__);
 
-    HDassert(_dest);
+    assert(_dest);
 
     n = (uint16_t)htons(v);
     H5MM_memcpy(_dest, &n, sizeof(n));
@@ -449,7 +449,7 @@ H5FD__mirror_xmit_encode_uint32(unsigned char *_dest, uint32_t v)
 
     LOG_OP_CALL(__func__);
 
-    HDassert(_dest);
+    assert(_dest);
 
     n = (uint32_t)htonl(v);
     H5MM_memcpy(_dest, &n, sizeof(n));
@@ -476,7 +476,7 @@ H5FD__mirror_xmit_encode_uint64(unsigned char *_dest, uint64_t v)
 
     LOG_OP_CALL(__func__);
 
-    HDassert(_dest);
+    assert(_dest);
 
     if (TRUE == is_host_little_endian())
         n = BSWAP_64(v);
@@ -503,7 +503,7 @@ H5FD__mirror_xmit_encode_uint8(unsigned char *dest, uint8_t v)
 {
     LOG_OP_CALL(__func__);
 
-    HDassert(dest);
+    assert(dest);
 
     H5MM_memcpy(dest, &v, sizeof(v));
 
@@ -536,14 +536,14 @@ H5FD_mirror_xmit_decode_header(H5FD_mirror_xmit_t *out, const unsigned char *buf
 
     LOG_OP_CALL(__func__);
 
-    HDassert(out && buf);
+    assert(out && buf);
 
     n_eaten += H5FD__mirror_xmit_decode_uint32(&(out->magic), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint8(&(out->version), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint32(&(out->session_token), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint32(&(out->xmit_count), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint8(&(out->op), &buf[n_eaten]);
-    HDassert(n_eaten == H5FD_MIRROR_XMIT_HEADER_SIZE);
+    assert(n_eaten == H5FD_MIRROR_XMIT_HEADER_SIZE);
 
     return n_eaten;
 } /* end H5FD_mirror_xmit_decode_header() */
@@ -574,11 +574,11 @@ H5FD_mirror_xmit_decode_lock(H5FD_mirror_xmit_lock_t *out, const unsigned char *
 
     LOG_OP_CALL(__func__);
 
-    HDassert(out && buf);
+    assert(out && buf);
 
     n_eaten += H5FD_mirror_xmit_decode_header(&(out->pub), buf);
     n_eaten += H5FD__mirror_xmit_decode_uint64(&(out->rw), &buf[n_eaten]);
-    HDassert(n_eaten == H5FD_MIRROR_XMIT_LOCK_SIZE);
+    assert(n_eaten == H5FD_MIRROR_XMIT_LOCK_SIZE);
 
     return n_eaten;
 } /* end H5FD_mirror_xmit_decode_lock() */
@@ -610,13 +610,13 @@ H5FD_mirror_xmit_decode_open(H5FD_mirror_xmit_open_t *out, const unsigned char *
 
     LOG_OP_CALL(__func__);
 
-    HDassert(out && buf);
+    assert(out && buf);
 
     n_eaten += H5FD_mirror_xmit_decode_header(&(out->pub), buf);
     n_eaten += H5FD__mirror_xmit_decode_uint32(&(out->flags), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint64(&(out->maxaddr), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint64(&(out->size_t_blob), &buf[n_eaten]);
-    HDassert((H5FD_MIRROR_XMIT_OPEN_SIZE - H5FD_MIRROR_XMIT_FILEPATH_MAX) == n_eaten);
+    assert((H5FD_MIRROR_XMIT_OPEN_SIZE - H5FD_MIRROR_XMIT_FILEPATH_MAX) == n_eaten);
     HDstrncpy(out->filename, (const char *)&buf[n_eaten], H5FD_MIRROR_XMIT_FILEPATH_MAX - 1);
     out->filename[H5FD_MIRROR_XMIT_FILEPATH_MAX - 1] = 0; /* force final NULL */
 
@@ -650,11 +650,11 @@ H5FD_mirror_xmit_decode_reply(H5FD_mirror_xmit_reply_t *out, const unsigned char
 
     LOG_OP_CALL(__func__);
 
-    HDassert(out && buf);
+    assert(out && buf);
 
     n_eaten += H5FD_mirror_xmit_decode_header(&(out->pub), buf);
     n_eaten += H5FD__mirror_xmit_decode_uint32(&(out->status), &buf[n_eaten]);
-    HDassert((H5FD_MIRROR_XMIT_REPLY_SIZE - H5FD_MIRROR_STATUS_MESSAGE_MAX) == n_eaten);
+    assert((H5FD_MIRROR_XMIT_REPLY_SIZE - H5FD_MIRROR_STATUS_MESSAGE_MAX) == n_eaten);
     HDstrncpy(out->message, (const char *)&buf[n_eaten], H5FD_MIRROR_STATUS_MESSAGE_MAX - 1);
     out->message[H5FD_MIRROR_STATUS_MESSAGE_MAX - 1] = 0; /* force NULL term */
 
@@ -687,12 +687,12 @@ H5FD_mirror_xmit_decode_set_eoa(H5FD_mirror_xmit_eoa_t *out, const unsigned char
 
     LOG_OP_CALL(__func__);
 
-    HDassert(out && buf);
+    assert(out && buf);
 
     n_eaten += H5FD_mirror_xmit_decode_header(&(out->pub), buf);
     n_eaten += H5FD__mirror_xmit_decode_uint8(&(out->type), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint64(&(out->eoa_addr), &buf[n_eaten]);
-    HDassert(n_eaten == H5FD_MIRROR_XMIT_EOA_SIZE);
+    assert(n_eaten == H5FD_MIRROR_XMIT_EOA_SIZE);
 
     return n_eaten;
 } /* end H5FD_mirror_xmit_decode_set_eoa() */
@@ -723,13 +723,13 @@ H5FD_mirror_xmit_decode_write(H5FD_mirror_xmit_write_t *out, const unsigned char
 
     LOG_OP_CALL(__func__);
 
-    HDassert(out && buf);
+    assert(out && buf);
 
     n_eaten += H5FD_mirror_xmit_decode_header(&(out->pub), buf);
     n_eaten += H5FD__mirror_xmit_decode_uint8(&(out->type), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint64(&(out->offset), &buf[n_eaten]);
     n_eaten += H5FD__mirror_xmit_decode_uint64(&(out->size), &buf[n_eaten]);
-    HDassert(n_eaten == H5FD_MIRROR_XMIT_WRITE_SIZE);
+    assert(n_eaten == H5FD_MIRROR_XMIT_WRITE_SIZE);
 
     return n_eaten;
 } /* end H5FD_mirror_xmit_decode_write() */
@@ -755,14 +755,14 @@ H5FD_mirror_xmit_encode_header(unsigned char *dest, const H5FD_mirror_xmit_t *x)
 
     LOG_OP_CALL(__func__);
 
-    HDassert(dest && x);
+    assert(dest && x);
 
     n_writ += H5FD__mirror_xmit_encode_uint32((dest + n_writ), x->magic);
     n_writ += H5FD__mirror_xmit_encode_uint8((dest + n_writ), x->version);
     n_writ += H5FD__mirror_xmit_encode_uint32((dest + n_writ), x->session_token);
     n_writ += H5FD__mirror_xmit_encode_uint32((dest + n_writ), x->xmit_count);
     n_writ += H5FD__mirror_xmit_encode_uint8((dest + n_writ), x->op);
-    HDassert(n_writ == H5FD_MIRROR_XMIT_HEADER_SIZE);
+    assert(n_writ == H5FD_MIRROR_XMIT_HEADER_SIZE);
 
     return n_writ;
 } /* end H5FD_mirror_xmit_encode_header() */
@@ -787,11 +787,11 @@ H5FD_mirror_xmit_encode_lock(unsigned char *dest, const H5FD_mirror_xmit_lock_t
 
     LOG_OP_CALL(__func__);
 
-    HDassert(dest && x);
+    assert(dest && x);
 
     n_writ += H5FD_mirror_xmit_encode_header(dest, (const H5FD_mirror_xmit_t *)&(x->pub));
     n_writ += H5FD__mirror_xmit_encode_uint64(&dest[n_writ], x->rw);
-    HDassert(n_writ == H5FD_MIRROR_XMIT_LOCK_SIZE);
+    assert(n_writ == H5FD_MIRROR_XMIT_LOCK_SIZE);
 
     return n_writ;
 } /* end H5FD_mirror_xmit_encode_lock() */
@@ -817,7 +817,7 @@ H5FD_mirror_xmit_encode_open(unsigned char *dest, const H5FD_mirror_xmit_open_t
 
     LOG_OP_CALL(__func__);
 
-    HDassert(dest && x);
+    assert(dest && x);
 
     /* clear entire structure, but especially its filepath string area */
     HDmemset(dest, 0, H5FD_MIRROR_XMIT_OPEN_SIZE);
@@ -826,7 +826,7 @@ H5FD_mirror_xmit_encode_open(unsigned char *dest, const H5FD_mirror_xmit_open_t
     n_writ += H5FD__mirror_xmit_encode_uint32(&dest[n_writ], x->flags);
     n_writ += H5FD__mirror_xmit_encode_uint64(&dest[n_writ], x->maxaddr);
     n_writ += H5FD__mirror_xmit_encode_uint64(&dest[n_writ], x->size_t_blob);
-    HDassert((H5FD_MIRROR_XMIT_OPEN_SIZE - H5FD_MIRROR_XMIT_FILEPATH_MAX) == n_writ);
+    assert((H5FD_MIRROR_XMIT_OPEN_SIZE - H5FD_MIRROR_XMIT_FILEPATH_MAX) == n_writ);
     HDstrncpy((char *)&dest[n_writ], x->filename, H5FD_MIRROR_XMIT_FILEPATH_MAX);
 
     return H5FD_MIRROR_XMIT_OPEN_SIZE;
@@ -854,14 +854,14 @@ H5FD_mirror_xmit_encode_reply(unsigned char *dest, const H5FD_mirror_xmit_reply_
 
     LOG_OP_CALL(__func__);
 
-    HDassert(dest && x);
+    assert(dest && x);
 
     /* clear entire structure, but especially its message string area */
     HDmemset(dest, 0, H5FD_MIRROR_XMIT_REPLY_SIZE);
 
     n_writ += H5FD_mirror_xmit_encode_header(dest, (const H5FD_mirror_xmit_t *)&(x->pub));
     n_writ += H5FD__mirror_xmit_encode_uint32(&dest[n_writ], x->status);
-    HDassert((H5FD_MIRROR_XMIT_REPLY_SIZE - H5FD_MIRROR_STATUS_MESSAGE_MAX) == n_writ);
+    assert((H5FD_MIRROR_XMIT_REPLY_SIZE - H5FD_MIRROR_STATUS_MESSAGE_MAX) == n_writ);
     HDstrncpy((char *)&dest[n_writ], x->message, H5FD_MIRROR_STATUS_MESSAGE_MAX);
 
     return H5FD_MIRROR_XMIT_REPLY_SIZE;
@@ -888,12 +888,12 @@ H5FD_mirror_xmit_encode_set_eoa(unsigned char *dest, const H5FD_mirror_xmit_eoa_
 
     LOG_OP_CALL(__func__);
 
-    HDassert(dest && x);
+    assert(dest && x);
 
     n_writ += H5FD_mirror_xmit_encode_header(dest, (const H5FD_mirror_xmit_t *)&(x->pub));
     n_writ += H5FD__mirror_xmit_encode_uint8(&dest[n_writ], x->type);
     n_writ += H5FD__mirror_xmit_encode_uint64(&dest[n_writ], x->eoa_addr);
-    HDassert(n_writ == H5FD_MIRROR_XMIT_EOA_SIZE);
+    assert(n_writ == H5FD_MIRROR_XMIT_EOA_SIZE);
 
     return n_writ;
 } /* end H5FD_mirror_xmit_encode_set_eoa() */
@@ -919,13 +919,13 @@ H5FD_mirror_xmit_encode_write(unsigned char *dest, const H5FD_mirror_xmit_write_
 
     LOG_OP_CALL(__func__);
 
-    HDassert(dest && x);
+    assert(dest && x);
 
     n_writ += H5FD_mirror_xmit_encode_header(dest, (const H5FD_mirror_xmit_t *)&(x->pub));
     n_writ += H5FD__mirror_xmit_encode_uint8(&dest[n_writ], x->type);
     n_writ += H5FD__mirror_xmit_encode_uint64(&dest[n_writ], x->offset);
     n_writ += H5FD__mirror_xmit_encode_uint64(&dest[n_writ], x->size);
-    HDassert(n_writ == H5FD_MIRROR_XMIT_WRITE_SIZE);
+    assert(n_writ == H5FD_MIRROR_XMIT_WRITE_SIZE);
 
     return n_writ;
 } /* end H5FD_mirror_xmit_encode_write() */
@@ -945,7 +945,7 @@ H5FD_mirror_xmit_is_close(const H5FD_mirror_xmit_t *xmit)
 {
     LOG_OP_CALL(__func__);
 
-    HDassert(xmit);
+    assert(xmit);
 
     if ((TRUE == H5FD_mirror_xmit_is_xmit(xmit)) && (H5FD_MIRROR_OP_CLOSE == xmit->op))
         return TRUE;
@@ -968,7 +968,7 @@ H5FD_mirror_xmit_is_lock(const H5FD_mirror_xmit_lock_t *xmit)
 {
     LOG_OP_CALL(__func__);
 
-    HDassert(xmit);
+    assert(xmit);
 
     if ((TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) && (H5FD_MIRROR_OP_LOCK == xmit->pub.op))
         return TRUE;
@@ -991,7 +991,7 @@ H5FD_mirror_xmit_is_open(const H5FD_mirror_xmit_open_t *xmit)
 {
     LOG_OP_CALL(__func__);
 
-    HDassert(xmit);
+    assert(xmit);
 
     if ((TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) && (H5FD_MIRROR_OP_OPEN == xmit->pub.op))
 
@@ -1015,7 +1015,7 @@ H5FD_mirror_xmit_is_set_eoa(const H5FD_mirror_xmit_eoa_t *xmit)
 {
     LOG_OP_CALL(__func__);
 
-    HDassert(xmit);
+    assert(xmit);
 
     if ((TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) && (H5FD_MIRROR_OP_SET_EOA == xmit->pub.op))
         return TRUE;
@@ -1038,7 +1038,7 @@ H5FD_mirror_xmit_is_reply(const H5FD_mirror_xmit_reply_t *xmit)
 {
     LOG_OP_CALL(__func__);
 
-    HDassert(xmit);
+    assert(xmit);
 
     if ((TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) && (H5FD_MIRROR_OP_REPLY == xmit->pub.op))
         return TRUE;
@@ -1061,7 +1061,7 @@ H5FD_mirror_xmit_is_write(const H5FD_mirror_xmit_write_t *xmit)
 {
     LOG_OP_CALL(__func__);
 
-    HDassert(xmit);
+    assert(xmit);
 
     if ((TRUE == H5FD_mirror_xmit_is_xmit(&(xmit->pub))) && (H5FD_MIRROR_OP_WRITE == xmit->pub.op))
         return TRUE;
@@ -1084,7 +1084,7 @@ H5FD_mirror_xmit_is_xmit(const H5FD_mirror_xmit_t *xmit)
 {
     LOG_OP_CALL(__func__);
 
-    HDassert(xmit);
+    assert(xmit);
 
     if ((H5FD_MIRROR_XMIT_MAGIC != xmit->magic) || (H5FD_MIRROR_XMIT_CURR_VERSION != xmit->version))
         return FALSE;
@@ -1115,7 +1115,7 @@ H5FD__mirror_verify_reply(H5FD_mirror_t *file)
 
     LOG_OP_CALL(__func__);
 
-    HDassert(file && file->sock_fd);
+    assert(file && file->sock_fd);
 
     xmit_buf = H5FL_BLK_MALLOC(xmit, H5FD_MIRROR_XMIT_BUFFER_MAX);
     if (NULL == xmit_buf)
@@ -1239,8 +1239,8 @@ H5FD__mirror_fapl_free(void *_fa)
     LOG_OP_CALL(__func__);
 
     /* sanity check */
-    HDassert(fa != NULL);
-    HDassert(fa->magic == H5FD_MIRROR_FAPL_MAGIC);
+    assert(fa != NULL);
+    assert(fa->magic == H5FD_MIRROR_FAPL_MAGIC);
 
     fa->magic += 1; /* invalidate */
     H5MM_xfree(fa);
@@ -1282,7 +1282,7 @@ H5Pget_fapl_mirror(hid_t fapl_id, H5FD_mirror_fapl_t *fa_dst /*out*/)
     if (NULL == fa_src)
         HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "bad VFL driver info");
 
-    HDassert(fa_src->magic == H5FD_MIRROR_FAPL_MAGIC); /* sanity check */
+    assert(fa_src->magic == H5FD_MIRROR_FAPL_MAGIC); /* sanity check */
 
     H5MM_memcpy(fa_dst, fa_src, sizeof(H5FD_mirror_fapl_t));
 
@@ -1482,8 +1482,8 @@ H5FD__mirror_close(H5FD_t *_file)
     LOG_OP_CALL(__func__);
 
     /* Sanity check */
-    HDassert(file);
-    HDassert(file->sock_fd >= 0);
+    assert(file);
+    assert(file->sock_fd >= 0);
 
     file->xmit.xmit_count = (file->xmit_i)++;
     file->xmit.op         = H5FD_MIRROR_OP_CLOSE;
@@ -1590,7 +1590,7 @@ H5FD__mirror_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 
     LOG_OP_CALL(__func__);
 
-    HDassert(file);
+    assert(file);
 
     FUNC_LEAVE_NOAPI(file->eoa)
 } /* end H5FD__mirror_get_eoa() */
@@ -1617,7 +1617,7 @@ H5FD__mirror_set_eoa(H5FD_t *_file, H5FD_mem_t type, haddr_t addr)
 
     LOG_OP_CALL(__func__);
 
-    HDassert(file);
+    assert(file);
 
     file->eoa = addr; /* local copy */
 
@@ -1672,7 +1672,7 @@ H5FD__mirror_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 
     LOG_OP_CALL(__func__);
 
-    HDassert(file);
+    assert(file);
 
     FUNC_LEAVE_NOAPI(file->eof)
 } /* end H5FD__mirror_get_eof() */
@@ -1726,8 +1726,8 @@ H5FD__mirror_write(H5FD_t *_file, H5FD_mem_t type, hid_t H5_ATTR_UNUSED dxpl_id,
 
     LOG_OP_CALL(__func__);
 
-    HDassert(file);
-    HDassert(buf);
+    assert(file);
+    assert(buf);
 
     file->xmit.xmit_count = (file->xmit_i)++;
     file->xmit.op         = H5FD_MIRROR_OP_WRITE;