[svn-r22105] Description:

	Bring r20557:22085 from trunk to this branch, also fixing some other
issues/failures in the branch simultaneously.  The h5repack tests are still
failing, but Neil will be checking into those, so the branch can be fully
functional again.

Tested on:
	Mac OSX/64 10.7.3 (amazon) w/debug

1 files changed, 181 insertions, 56 deletions

diff --git a/src/H5Ztrans.c b/src/H5Ztrans.c
index 8028123..2a2796d 100644
--- a/src/H5Ztrans.c
+++ b/src/H5Ztrans.c
@@ -94,6 +94,8 @@ static H5Z_node *H5Z_parse_term(H5Z_token *current, H5Z_datval_ptrs* dat_val_poi
 static H5Z_node *H5Z_parse_factor(H5Z_token *current, H5Z_datval_ptrs* dat_val_pointers);
 static H5Z_node *H5Z_new_node(H5Z_token_type type);
 static void H5Z_do_op(H5Z_node* tree);
+static hbool_t H5Z_op_is_numbs(H5Z_node* _tree);
+static hbool_t H5Z_op_is_numbs2(H5Z_node* _tree);
 static hid_t H5Z_xform_find_type(const H5T_t* type);
 static herr_t H5Z_xform_eval_full(H5Z_node *tree, const size_t array_size, const hid_t array_type, H5Z_result* res);
 static void H5Z_xform_destroy_parse_tree(H5Z_node *tree);
@@ -105,41 +107,46 @@ static void H5Z_XFORM_DEBUG(H5Z_node *tree);
 static void H5Z_print(H5Z_node *tree, FILE *stream);
 #endif  /* H5Z_XFORM_DEBUG */
 
-
 #define H5Z_XFORM_DO_OP1(RESL,RESR,TYPE,OP,SIZE)                            \
 {   								  	    \
-    if( (((RESL).type == H5Z_XFORM_SYMBOL) && ((RESR).type != H5Z_XFORM_SYMBOL)) || (((RESR).type == H5Z_XFORM_SYMBOL) && ((RESL).type != H5Z_XFORM_SYMBOL))) \
+    size_t u;                                                               \
+                                                                            \
+    if(((RESL).type == H5Z_XFORM_SYMBOL) && ((RESR).type != H5Z_XFORM_SYMBOL)) \
+    {   								    \
+	TYPE* p;                                                            \
+	double tree_val;                                                    \
+		                                                            \
+	tree_val = ((RESR).type==H5Z_XFORM_INTEGER ? (double)(RESR).value.int_val : (RESR).value.float_val); \
+	p = (TYPE*)(RESL).value.dat_val;                                    \
+                                                                            \
+	for(u=0; u<(SIZE); u++)                                             \
+	    *p++ = *p OP tree_val;                                          \
+    }									    \
+    else if(((RESR).type == H5Z_XFORM_SYMBOL) && ((RESL).type != H5Z_XFORM_SYMBOL)) \
     {   								    \
-	size_t u;                                                           \
 	TYPE* p;                                                            \
 	double tree_val;                                                    \
 		                                                            \
-	if((RESL).type == H5Z_XFORM_SYMBOL)                                 \
-	{                                                                   \
-	    tree_val = ((RESR).type==H5Z_XFORM_INTEGER ? (double)(RESR).value.int_val : (RESR).value.float_val); \
-	    p = (TYPE*)(RESL).value.dat_val;                                \
-	}                                                                   \
+        /* The case that the left operand is nothing, like -x or +x */      \
+	if((RESL).type == H5Z_XFORM_ERROR)                                  \
+            tree_val = 0;                                                   \
 	else                                                                \
-	{                                                                   \
 	    tree_val = ((RESL).type==H5Z_XFORM_INTEGER ? (double)(RESL).value.int_val : (RESL).value.float_val); \
-	    p = (TYPE*)(RESR).value.dat_val;                                \
-	}                                                                   \
-		                                                            \
+                                                                            \
+	p = (TYPE*)(RESR).value.dat_val;                                    \
 	for(u=0; u<(SIZE); u++)                                             \
-	    *p++ OP tree_val;                                               \
-    }										\
+	    *p++ = tree_val OP *p;                                          \
+    }									    \
     else if( ((RESL).type == H5Z_XFORM_SYMBOL) && ((RESR).type==H5Z_XFORM_SYMBOL))  \
     {										\
-	size_t u;                                                           	\
 	TYPE* pl = (TYPE*)(RESL).value.dat_val;                             	\
 	TYPE* pr = (TYPE*)(RESR).value.dat_val;                             	\
 										\
 	for(u=0; u<(SIZE); u++)                                             	\
-	    *pl++ OP *pr++;                                                 	\
+	    *pl++ = *pl OP *pr++;                                           	\
     }										\
     else									\
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Unexpected type conversion operation")	\
-										\
 }
 
 /* Due to the undefined nature of embedding macros/conditionals within macros, we employ
@@ -235,6 +242,7 @@ static void H5Z_print(H5Z_node *tree, FILE *stream);
 }
 #endif /*H5_SIZEOF_LONG_DOUBLE */
 
+
 #define H5Z_XFORM_DO_OP3(OP)                                                                                                                    \
 {                                                                                                                                               \
         if((tree->lchild->type == H5Z_XFORM_INTEGER) && (tree->rchild->type==H5Z_XFORM_INTEGER))                                                \
@@ -259,6 +267,48 @@ static void H5Z_print(H5Z_node *tree, FILE *stream);
         }																	\
 }
 
+/* The difference of this macro from H5Z_XFORM_DO_OP3 is that it handles the operations when the left operand is empty, like -x or +x.  
+ * The reason that it's seperated from H5Z_XFORM_DO_OP3 is because compilers don't accept operations like *x or /x.  So in H5Z_do_op, 
+ * these two macros are called in different ways. 
+ */
+#define H5Z_XFORM_DO_OP6(OP)                                                                                                                    \
+{                                                                                                                                               \
+        if(!tree->lchild && (tree->rchild->type==H5Z_XFORM_INTEGER))                                                                            \
+        {																	\
+            tree->type = H5Z_XFORM_INTEGER;													\
+            tree->value.int_val = OP tree->rchild->value.int_val;							                        \
+            H5MM_xfree(tree->rchild);														\
+            tree->rchild = NULL;														\
+        }	                                                                                                                                \
+        else if(!tree->lchild && (tree->rchild->type==H5Z_XFORM_FLOAT))                                                                         \
+        {																	\
+            tree->type = H5Z_XFORM_FLOAT;													\
+            tree->value.float_val = OP tree->rchild->value.float_val;							                        \
+            H5MM_xfree(tree->rchild);														\
+            tree->rchild = NULL;														\
+        }	                                                                                                                                \
+        else if((tree->lchild->type == H5Z_XFORM_INTEGER) && (tree->rchild->type==H5Z_XFORM_INTEGER))                                           \
+        {																	\
+            tree->type = H5Z_XFORM_INTEGER;													\
+            tree->value.int_val = tree->lchild->value.int_val OP tree->rchild->value.int_val;							\
+            H5MM_xfree(tree->lchild);														\
+            H5MM_xfree(tree->rchild);														\
+            tree->lchild = NULL;														\
+            tree->rchild = NULL;														\
+        }																	\
+	else if( ( (tree->lchild->type == H5Z_XFORM_FLOAT) || (tree->lchild->type == H5Z_XFORM_INTEGER)) && 					\
+	            ( (tree->rchild->type == H5Z_XFORM_FLOAT) || (tree->rchild->type == H5Z_XFORM_INTEGER)))					\
+	{																	\
+	    tree->type = H5Z_XFORM_FLOAT;													\
+            tree->value.float_val = ((tree->lchild->type == H5Z_XFORM_FLOAT) ? tree->lchild->value.float_val : (double)tree->lchild->value.int_val) OP 	\
+				    ((tree->rchild->type == H5Z_XFORM_FLOAT) ? tree->rchild->value.float_val : (double)tree->rchild->value.int_val);	\
+            H5MM_xfree(tree->lchild);														\
+            H5MM_xfree(tree->rchild);														\
+            tree->lchild = NULL;														\
+            tree->rchild = NULL;														\
+        }																	\
+}
+
 #define H5Z_XFORM_DO_OP4(TYPE)                                                                                          \
 {                                                                                                                       \
     if ((ret_value = (H5Z_node*) H5MM_malloc(sizeof(H5Z_node))) == NULL)                                                \
@@ -317,19 +367,16 @@ static void H5Z_print(H5Z_node *tree, FILE *stream);
 static void
 H5Z_unget_token(H5Z_token *current)
 {
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
+
     /* check args */
     assert(current);
 
-
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5Z_unget_token)
-
     current->tok_type = current->tok_last_type;
     current->tok_begin = current->tok_last_begin;
     current->tok_end = current->tok_last_end;
 
     FUNC_LEAVE_NOAPI_VOID
-
-
 }
 
 
@@ -356,7 +403,7 @@ H5Z_get_token(H5Z_token *current)
 {
     H5Z_token *ret_value = current;
 
-    FUNC_ENTER_NOAPI(H5Z_get_token, NULL)
+    FUNC_ENTER_NOAPI_NOINIT
 
     /* check args */
     assert(current);
@@ -485,7 +532,7 @@ done:
 void
 H5Z_xform_destroy_parse_tree(H5Z_node *tree)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5Z_xform_destroy_parse_tree)
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     if (tree)
     {
@@ -518,7 +565,7 @@ H5Z_xform_parse(const char *expression, H5Z_datval_ptrs* dat_val_pointers)
     H5Z_token tok;
     void* ret_value;
 
-    FUNC_ENTER_NOAPI(H5Z_xform_parse, NULL)
+    FUNC_ENTER_NOAPI(NULL)
 
     if(!expression)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "No expression provided?")
@@ -557,7 +604,7 @@ H5Z_parse_expression(H5Z_token *current, H5Z_datval_ptrs* dat_val_pointers)
     H5Z_node *expr;
     H5Z_node *ret_value;        /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT(H5Z_parse_expression)
+    FUNC_ENTER_NOAPI_NOINIT
 
     expr = H5Z_parse_term(current, dat_val_pointers);
 
@@ -651,7 +698,8 @@ H5Z_parse_term(H5Z_token *current, H5Z_datval_ptrs* dat_val_pointers)
     H5Z_node *term = NULL;
     H5Z_node *ret_value;
 
-    FUNC_ENTER_NOAPI(H5Z_parse_term, NULL);
+    FUNC_ENTER_NOAPI_NOINIT
+
     term = H5Z_parse_factor(current, dat_val_pointers);
 
     for (;;) {
@@ -741,7 +789,7 @@ H5Z_parse_factor(H5Z_token *current, H5Z_datval_ptrs* dat_val_pointers)
     H5Z_node 	*new_node;
     H5Z_node    *ret_value;
 
-    FUNC_ENTER_NOAPI(H5Z_parse_factor, NULL);
+    FUNC_ENTER_NOAPI_NOINIT
 
     current = H5Z_get_token(current);
 
@@ -880,7 +928,7 @@ H5Z_new_node(H5Z_token_type type)
 {
     H5Z_node *ret_value;
 
-    FUNC_ENTER_NOAPI(H5Z_new_node, NULL)
+    FUNC_ENTER_NOAPI_NOINIT
 
     if(NULL == (ret_value = (H5Z_node *)H5MM_calloc(sizeof(H5Z_node))))
 	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "Ran out of memory trying to allocate space for nodes in the parse tree")
@@ -913,7 +961,7 @@ H5Z_xform_eval(H5Z_data_xform_t *data_xform_prop, void* array, size_t array_size
     size_t i;
     herr_t ret_value = SUCCEED;         /* Return value */
 
-    FUNC_ENTER_NOAPI(H5Z_xform_eval, FAIL)
+    FUNC_ENTER_NOAPI(FAIL)
 
     HDassert(data_xform_prop);
 
@@ -1024,11 +1072,14 @@ H5Z_xform_eval_full(H5Z_node *tree, const size_t array_size,  const hid_t array_
     H5Z_result resl, resr;
     herr_t ret_value = SUCCEED;         /* Return value */
 
-    FUNC_ENTER_NOAPI(H5Z_xform_eval_full, FAIL)
+    FUNC_ENTER_NOAPI_NOINIT
 
     /* check args */
     HDassert(tree);
 
+    HDmemset(&resl, 0, sizeof(H5Z_result));
+    HDmemset(&resr, 0, sizeof(H5Z_result));
+
     if (tree->type == H5Z_XFORM_INTEGER) {
 	res->type = H5Z_XFORM_INTEGER;
 	res->value.int_val = tree->value.int_val;
@@ -1046,7 +1097,7 @@ H5Z_xform_eval_full(H5Z_node *tree, const size_t array_size,  const hid_t array_
 	res->value.dat_val = *((void**)(tree->value.dat_val));
     } /* end if */
     else {
-	if(H5Z_xform_eval_full(tree->lchild, array_size, array_type, &resl) < 0)
+	if(tree->lchild && H5Z_xform_eval_full(tree->lchild, array_size, array_type, &resl) < 0)
 	    HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "error while performing data transform")
 	if(H5Z_xform_eval_full(tree->rchild, array_size, array_type, &resr) < 0)
 	    HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "error while performing data transform")
@@ -1061,19 +1112,19 @@ H5Z_xform_eval_full(H5Z_node *tree, const size_t array_size,  const hid_t array_
 
 	switch (tree->type) {
 	    case H5Z_XFORM_PLUS:
-		H5Z_XFORM_TYPE_OP(resl, resr, array_type, +=, array_size)
+	 	H5Z_XFORM_TYPE_OP(resl, resr, array_type, +, array_size)
 		break;
 
 	    case H5Z_XFORM_MINUS:
-		H5Z_XFORM_TYPE_OP(resl, resr, array_type, -=, array_size)
+	 	H5Z_XFORM_TYPE_OP(resl, resr, array_type, -, array_size)
 		break;
 
 	    case H5Z_XFORM_MULT:
-		H5Z_XFORM_TYPE_OP(resl, resr, array_type, *=, array_size)
+		H5Z_XFORM_TYPE_OP(resl, resr, array_type, *, array_size)
 		break;
 
 	    case H5Z_XFORM_DIVIDE:
-		H5Z_XFORM_TYPE_OP(resl, resr, array_type, /=, array_size)
+	 	H5Z_XFORM_TYPE_OP(resl, resr, array_type, /, array_size)
 		break;
 
 	    default:
@@ -1111,7 +1162,7 @@ H5Z_xform_find_type(const H5T_t* type)
     H5T_t *tmp;                         /* Temporary datatype */
     hid_t ret_value = SUCCEED;          /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT(H5Z_xform_find_type)
+    FUNC_ENTER_NOAPI_NOINIT
 
     HDassert(type);
 
@@ -1197,7 +1248,7 @@ H5Z_xform_copy_tree(H5Z_node* tree, H5Z_datval_ptrs* dat_val_pointers, H5Z_datva
 {
     H5Z_node* ret_value=NULL;
 
-    FUNC_ENTER_NOAPI(H5Z_xform_copy_tree, NULL)
+    FUNC_ENTER_NOAPI(NULL)
 
     assert(tree);
 
@@ -1273,25 +1324,40 @@ H5Z_xform_copy_tree(H5Z_node* tree, H5Z_datval_ptrs* dat_val_pointers, H5Z_datva
 void
 H5Z_xform_reduce_tree(H5Z_node* tree)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5Z_xform_reduce_tree)
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     if(tree) {
-        if((tree->type == H5Z_XFORM_PLUS) || (tree->type == H5Z_XFORM_DIVIDE) ||(tree->type == H5Z_XFORM_MULT) ||(tree->type == H5Z_XFORM_MINUS))
+        if((tree->type == H5Z_XFORM_DIVIDE) || (tree->type == H5Z_XFORM_MULT))
         {
-            if(((tree->lchild->type == H5Z_XFORM_INTEGER) || (tree->lchild->type == H5Z_XFORM_FLOAT)) && ((tree->rchild->type == H5Z_XFORM_INTEGER) || (tree->rchild->type == H5Z_XFORM_FLOAT)))
+            if(H5Z_op_is_numbs(tree))
+                H5Z_do_op(tree);
+            else
+            {
+                H5Z_xform_reduce_tree(tree->lchild);
+                if(H5Z_op_is_numbs(tree))
+                    H5Z_do_op(tree);
+                else {
+                    H5Z_xform_reduce_tree(tree->rchild);
+                    if(H5Z_op_is_numbs(tree))
+                        H5Z_do_op(tree);
+                }
+            }
+        } else if((tree->type == H5Z_XFORM_PLUS) || (tree->type == H5Z_XFORM_MINUS)) {
+            if(H5Z_op_is_numbs2(tree))
                 H5Z_do_op(tree);
             else
             {
                 H5Z_xform_reduce_tree(tree->lchild);
-                if(((tree->lchild->type == H5Z_XFORM_INTEGER) || (tree->lchild->type == H5Z_XFORM_FLOAT)) && ((tree->rchild->type == H5Z_XFORM_INTEGER) || (tree->rchild->type == H5Z_XFORM_FLOAT)))
+                if(H5Z_op_is_numbs2(tree))
                     H5Z_do_op(tree);
                 else {
                     H5Z_xform_reduce_tree(tree->rchild);
-                    if(((tree->lchild->type == H5Z_XFORM_INTEGER) || (tree->lchild->type == H5Z_XFORM_FLOAT)) && ((tree->rchild->type == H5Z_XFORM_INTEGER) || (tree->rchild->type == H5Z_XFORM_FLOAT)))
+                    if(H5Z_op_is_numbs2(tree))
                         H5Z_do_op(tree);
                 }
             }
         }
+
     }
 
     FUNC_LEAVE_NOAPI_VOID;
@@ -1299,6 +1365,63 @@ H5Z_xform_reduce_tree(H5Z_node* tree)
 
 
 /*-------------------------------------------------------------------------
+ * Function:    H5Z_op_is_numbs
+ * Purpose:     Internal function to facilitate the condition check in 
+ *              H5Z_xform_reduce_tree to reduce the bulkiness of the code.
+ * Return:      TRUE or FALSE
+ * Programmer:  Raymond Lu
+ *              15 March 2012
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static hbool_t
+H5Z_op_is_numbs(H5Z_node* _tree)
+{
+    hbool_t ret_value = FALSE;
+
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
+
+    assert(_tree);
+
+    if(((_tree->lchild->type == H5Z_XFORM_INTEGER) || (_tree->lchild->type == H5Z_XFORM_FLOAT)) && ((_tree->rchild->type == H5Z_XFORM_INTEGER) || (_tree->rchild->type == H5Z_XFORM_FLOAT)))
+      ret_value = TRUE;
+
+    FUNC_LEAVE_NOAPI(ret_value)
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5Z_op_is_numbs2
+ * Purpose:     Internal function to facilitate the condition check in 
+ *              H5Z_xform_reduce_tree to reduce the bulkiness of the code.
+ *              The difference from H5Z_op_is_numbs is that the left child
+ *              can be empty, like -x or +x.
+ * Return:      TRUE or FALSE
+ * Programmer:  Raymond Lu
+ *              15 March 2012
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static hbool_t
+H5Z_op_is_numbs2(H5Z_node* _tree)
+{
+    hbool_t ret_value = FALSE;
+
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
+
+    assert(_tree);
+
+    if((!_tree->lchild && ((_tree->rchild->type == H5Z_XFORM_INTEGER) || (_tree->rchild->type == H5Z_XFORM_FLOAT))) ||
+       ((_tree->lchild && ((_tree->lchild->type == H5Z_XFORM_INTEGER) || (_tree->lchild->type == H5Z_XFORM_FLOAT))) && (_tree->rchild && ((_tree->rchild->type == H5Z_XFORM_INTEGER) || (_tree->rchild->type == H5Z_XFORM_FLOAT)))))
+      ret_value = TRUE;
+
+    FUNC_LEAVE_NOAPI(ret_value)
+}
+
+
+/*-------------------------------------------------------------------------
  * Function:    H5Z_do_op
  * Purpose:     If the root of the tree passed in points to a simple
  *              arithmetic operation and the left and right subtrees are both
@@ -1309,26 +1432,28 @@ H5Z_xform_reduce_tree(H5Z_node* tree)
  * Programmer:  Leon Arber
  *              April 1, 2004.
  * Modifications:
-*
+ *              Raymond Lu
+ *              15 March 2012
+ *              I added a new macro H5Z_XFORM_DO_OP6 to handle the special
+ *              operations like -x or +x when the left operand is empty.
+ *
  *-------------------------------------------------------------------------
  */
 static void
 H5Z_do_op(H5Z_node* tree)
 {
-
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5Z_do_op)
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     if(tree->type == H5Z_XFORM_DIVIDE)
 	H5Z_XFORM_DO_OP3(/)
     else if(tree->type == H5Z_XFORM_MULT)
 	H5Z_XFORM_DO_OP3(*)
     else if(tree->type == H5Z_XFORM_PLUS)
-	H5Z_XFORM_DO_OP3(+)
+	H5Z_XFORM_DO_OP6(+)
     else if(tree->type == H5Z_XFORM_MINUS)
-	H5Z_XFORM_DO_OP3(-)
+	H5Z_XFORM_DO_OP6(-)
 
     FUNC_LEAVE_NOAPI_VOID;
-
 }
 
 
@@ -1359,7 +1484,7 @@ H5Z_xform_create(const char *expr)
     unsigned int i;
     unsigned int count = 0;
 
-    FUNC_ENTER_NOAPI(H5Z_xform_create, NULL)
+    FUNC_ENTER_NOAPI(NULL)
 
     assert(expr);
 
@@ -1383,7 +1508,7 @@ H5Z_xform_create(const char *expr)
      * we don't need to allocate any space since no array will have to be
      * stored */
     if(count > 0)
-	if((data_xform_prop->dat_val_pointers->ptr_dat_val = (void**) H5MM_calloc(count * sizeof(void**))) == NULL)
+	if(NULL == (data_xform_prop->dat_val_pointers->ptr_dat_val = (void *)H5MM_calloc(count * sizeof(void *))))
 	    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "unable to allocate memory for pointers in transform array")
 
     /* Initialize the num_ptrs field, which will be used to keep track of the number of copies
@@ -1445,7 +1570,7 @@ done:
 herr_t
 H5Z_xform_destroy(H5Z_data_xform_t *data_xform_prop)
 {
-    FUNC_ENTER_NOAPI_NOFUNC(H5Z_xform_destroy)
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     if(data_xform_prop) {
 	/* Destroy the parse tree */
@@ -1498,7 +1623,7 @@ H5Z_xform_copy(H5Z_data_xform_t **data_xform_prop)
     H5Z_data_xform_t *new_data_xform_prop=NULL;
     herr_t ret_value=SUCCEED;
 
-    FUNC_ENTER_NOAPI(H5Z_xform_copy, FAIL)
+    FUNC_ENTER_NOAPI(FAIL)
 
     if(*data_xform_prop) {
         /* Allocate new node */
@@ -1518,7 +1643,7 @@ H5Z_xform_copy(H5Z_data_xform_t **data_xform_prop)
 		count++;
 
 	if(count > 0)
-	    if((new_data_xform_prop->dat_val_pointers->ptr_dat_val = (void**) H5MM_calloc(count * sizeof(void**))) == NULL)
+	    if(NULL == (new_data_xform_prop->dat_val_pointers->ptr_dat_val = (void *)H5MM_calloc(count * sizeof(void *))))
 		HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate memory for pointers in transform array")
 
 	/* Zero out num_pointers prior to H5Z_xform_cop_tree call; that call will increment it to the right amount */
@@ -1575,7 +1700,7 @@ H5Z_xform_noop(const H5Z_data_xform_t *data_xform_prop)
 {
     hbool_t ret_value;
 
-    FUNC_ENTER_NOAPI_NOFUNC(H5Z_xform_noop)
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     ret_value=(data_xform_prop ? FALSE : TRUE);
 
@@ -1604,7 +1729,7 @@ H5Z_xform_extract_xform_str(const H5Z_data_xform_t *data_xform_prop)
 {
     char* ret_value;
 
-    FUNC_ENTER_NOAPI_NOFUNC(H5Z_xform_extract_xform_str)
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* There should be no way that this can be NULL since the function
      * that calls this one checks to make sure it isn't before