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

* Change HDassert to assert

* Fix bin/make_err

1 files changed, 25 insertions, 25 deletions

diff --git a/src/H5Bdbg.c b/src/H5Bdbg.c
index 6e4c4b2..46ed7f4 100644
--- a/src/H5Bdbg.c
+++ b/src/H5Bdbg.c
@@ -62,21 +62,21 @@ H5B_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, const H5
     /*
      * Check arguments.
      */
-    HDassert(f);
-    HDassert(H5_addr_defined(addr));
-    HDassert(stream);
-    HDassert(indent >= 0);
-    HDassert(fwidth >= 0);
-    HDassert(type);
+    assert(f);
+    assert(H5_addr_defined(addr));
+    assert(stream);
+    assert(indent >= 0);
+    assert(fwidth >= 0);
+    assert(type);
 
     /* Currently does not support SWMR access */
-    HDassert(!(H5F_INTENT(f) & H5F_ACC_SWMR_WRITE));
+    assert(!(H5F_INTENT(f) & H5F_ACC_SWMR_WRITE));
 
     /* Get shared info for B-tree */
     if (NULL == (rc_shared = (type->get_shared)(f, udata)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTGET, FAIL, "can't retrieve B-tree's shared ref. count object")
     shared = (H5B_shared_t *)H5UC_GET_OBJ(rc_shared);
-    HDassert(shared);
+    assert(shared);
 
     /*
      * Load the tree node.
@@ -116,12 +116,12 @@ H5B_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, const H5
         if (type->debug_key) {
             /* Decode the 'left' key & print it */
             HDfprintf(stream, "%*s%-*s\n", indent + 3, "", MAX(3, fwidth) - 3, "Left Key:");
-            HDassert(H5B_NKEY(bt, shared, u));
+            assert(H5B_NKEY(bt, shared, u));
             (void)(type->debug_key)(stream, indent + 6, MAX(6, fwidth) - 6, H5B_NKEY(bt, shared, u), udata);
 
             /* Decode the 'right' key & print it */
             HDfprintf(stream, "%*s%-*s\n", indent + 3, "", MAX(3, fwidth) - 3, "Right Key:");
-            HDassert(H5B_NKEY(bt, shared, u + 1));
+            assert(H5B_NKEY(bt, shared, u + 1));
             (void)(type->debug_key)(stream, indent + 6, MAX(6, fwidth) - 6, H5B_NKEY(bt, shared, u + 1),
                                     udata);
         } /* end if */
@@ -179,24 +179,24 @@ H5B__assert(H5F_t *f, haddr_t addr, const H5B_class_t *type, void *udata)
     if (NULL == (rc_shared = (type->get_shared)(f, udata)))
         HGOTO_ERROR(H5E_BTREE, H5E_CANTGET, FAIL, "can't retrieve B-tree's shared ref. count object")
     shared = (H5B_shared_t *)H5UC_GET_OBJ(rc_shared);
-    HDassert(shared);
+    assert(shared);
 
     /* Initialize the queue */
     cache_udata.f         = f;
     cache_udata.type      = type;
     cache_udata.rc_shared = rc_shared;
     bt                    = (H5B_t *)H5AC_protect(f, H5AC_BT, addr, &cache_udata, H5AC__READ_ONLY_FLAG);
-    HDassert(bt);
+    assert(bt);
     shared = (H5B_shared_t *)H5UC_GET_OBJ(bt->rc_shared);
-    HDassert(shared);
+    assert(shared);
     cur = (struct child_t *)H5MM_calloc(sizeof(struct child_t));
-    HDassert(cur);
+    assert(cur);
     cur->addr  = addr;
     cur->level = bt->level;
     head = tail = cur;
 
     status = H5AC_unprotect(f, H5AC_BT, addr, bt, H5AC__NO_FLAGS_SET);
-    HDassert(status >= 0);
+    assert(status >= 0);
     bt = NULL; /* Make certain future references will be caught */
 
     /*
@@ -207,18 +207,18 @@ H5B__assert(H5F_t *f, haddr_t addr, const H5B_class_t *type, void *udata)
      */
     for (ncell = 0; cur; ncell++) {
         bt = (H5B_t *)H5AC_protect(f, H5AC_BT, cur->addr, &cache_udata, H5AC__READ_ONLY_FLAG);
-        HDassert(bt);
+        assert(bt);
 
         /* Check node header */
-        HDassert(bt->level == cur->level);
+        assert(bt->level == cur->level);
         if (cur->next && cur->next->level == bt->level)
-            HDassert(H5_addr_eq(bt->right, cur->next->addr));
+            assert(H5_addr_eq(bt->right, cur->next->addr));
         else
-            HDassert(!H5_addr_defined(bt->right));
+            assert(!H5_addr_defined(bt->right));
         if (prev && prev->level == bt->level)
-            HDassert(H5_addr_eq(bt->left, prev->addr));
+            assert(H5_addr_eq(bt->left, prev->addr));
         else
-            HDassert(!H5_addr_defined(bt->left));
+            assert(!H5_addr_defined(bt->left));
 
         if (cur->level > 0) {
             unsigned u;
@@ -229,11 +229,11 @@ H5B__assert(H5F_t *f, haddr_t addr, const H5B_class_t *type, void *udata)
                  * have then the tree has a cycle.
                  */
                 for (tmp = head; tmp; tmp = tmp->next)
-                    HDassert(H5_addr_ne(tmp->addr, bt->child[u]));
+                    assert(H5_addr_ne(tmp->addr, bt->child[u]));
 
                 /* Add the child node to the end of the queue */
                 tmp = (struct child_t *)H5MM_calloc(sizeof(struct child_t));
-                HDassert(tmp);
+                assert(tmp);
                 tmp->addr  = bt->child[u];
                 tmp->level = bt->level - 1;
                 tail->next = tmp;
@@ -241,13 +241,13 @@ H5B__assert(H5F_t *f, haddr_t addr, const H5B_class_t *type, void *udata)
 
                 /* Check that the keys are monotonically increasing */
                 cmp = (type->cmp2)(H5B_NKEY(bt, shared, u), udata, H5B_NKEY(bt, shared, u + 1));
-                HDassert(cmp < 0);
+                assert(cmp < 0);
             } /* end for */
         }     /* end if */
 
         /* Release node */
         status = H5AC_unprotect(f, H5AC_BT, cur->addr, bt, H5AC__NO_FLAGS_SET);
-        HDassert(status >= 0);
+        assert(status >= 0);
         bt = NULL; /* Make certain future references will be caught */
 
         /* Advance current location in queue */