Changeset 1548

Timestamp:

06/10/10 19:57:35 (20 months ago)

Author:

Tobias Richter

Message:

create new error reporting function that only takes a message as parameter
and use that throughout the api
refs #219

Location:

trunk

Files:

• bindings/swig/nxinterhelper.c (modified) (3 diffs)
• include/napi.h (modified) (1 diff)
• src/napi.c (modified) (27 diffs)
• src/napi4.c (modified) (69 diffs)
• src/napi5.c (modified) (63 diffs)
• src/napiu.c (modified) (1 diff)
• src/nexus_symbols.txt (modified) (1 diff)
• src/nxxml.c (modified) (53 diffs)

trunk/bindings/swig/nxinterhelper.c

@@ -208 +208 @@
   dimData = (pNXDS)dimPtr;
   if(dimData->type != NX_INT32){
-    NXIReportError(NULL,"ERROR: dimension data not integer");
+    NXReportError("ERROR: dimension data not integer");
     return 0;
   }
@@ -229 +229 @@
   dimData = (pNXDS)dimPtr;
   if(dimData->type != NX_INT32){
-    NXIReportError(NULL,"ERROR: dimension data not integer");
+    NXReportError("ERROR: dimension data not integer");
     return 0;
   }
@@ -416 +416 @@
 
   if(data == NULL){
-    NXIReportError(NULL,"ERROR: NULL data pointer in nx_putdata");
+    NXReportError("ERROR: NULL data pointer in nx_putdata");
     return 0;
   }

trunk/include/napi.h

@@ -787 +787 @@
 extern  void  NXMEnableErrorReporting();
 
-
+ /**
+  * Dispatches the error message to the error function defined by NXMSetTError
+  */
+extern void NXReportError(char *text);
+
+ /**
+  * Do not use, first parameter should be set by NXMSetTError
+  */
 extern void NXIReportError(void *pData,char *text);
-extern void *NXpData;
+/* extern void *NXpData; */
 extern char *NXIformatNeXusTime();
 extern  NXstatus  NXIprintlink(NXhandle fid, NXlink* link);

trunk/src/napi.c

@@ -196 +196 @@
 
   void NXIReportError(void *pData, char *string) {
-
+        fprintf(stderr, "Your application uses NXIReportError, but its first parameter is ignored now.");
+        NXReportError(string);
+  }
+
+  void NXReportError(char *string) {
         if (NXEHIReportTError) {
                 (*NXEHIReportTError)(NXEHpTData, string);
@@ -331 +335 @@
   fileStack = makeFileStack();
   if(fileStack == NULL){
-    NXIReportError (NXpData,"ERROR: no memory to create filestack");
+    NXReportError("ERROR: no memory to create filestack");
       return NX_ERROR;
   }
@@ -365 +369 @@
     fHandle = (pNexusFunction)malloc(sizeof(NexusFunction));
     if (fHandle == NULL) {
-      NXIReportError (NXpData,"ERROR: no memory to create Function structure");
+      NXReportError("ERROR: no memory to create Function structure");
       return NX_ERROR;
     }
@@ -398 +402 @@
       filename = locateNexusFileInPath((char *)userfilename);
       if(filename == NULL){
-        NXIReportError(NXpData,"Out of memory in NeXus-API");
+        NXReportError("Out of memory in NeXus-API");
         free(fHandle);
         return NX_ERROR;
@@ -407 +411 @@
         snprintf(error,1023,"failed to open %s for reading",
                  filename);
-        NXIReportError(NXpData,error);
+        NXReportError(error);
         free(filename);
         return NX_ERROR;
@@ -414 +418 @@
         snprintf(error,1023,"failed to determine filetype for %s ",
                  filename);
-        NXIReportError(NXpData,error);
+        NXReportError(error);
         free(filename);
         free(fHandle);
@@ -422 +426 @@
     }
     if(filename == NULL){
-        NXIReportError(NXpData,"Out of memory in NeXus-API");
+        NXReportError("Out of memory in NeXus-API");
         return NX_ERROR;
     }
@@ -439 +443 @@
       pushFileStack(fileStack,fHandle,filename);
 #else
-      NXIReportError (NXpData,
+      NXReportError(
          "ERROR: Attempt to create HDF4 file when not linked with HDF4");
       retstat = NX_ERROR;
@@ -458 +462 @@
       pushFileStack(fileStack,fHandle, filename);
 #else
-      NXIReportError (NXpData,
+      NXReportError(
          "ERROR: Attempt to create HDF5 file when not linked with HDF5");
       retstat = NX_ERROR;
@@ -479 +483 @@
       pushFileStack(fileStack,fHandle, filename);
 #else
-      NXIReportError (NXpData,
+      NXReportError(
          "ERROR: Attempt to create XML file when not linked with XML");
       retstat = NX_ERROR;
 #endif
     } else {
-      NXIReportError (NXpData,
+      NXReportError(
           "ERROR: Format not readable by this NeXus library");
       retstat = NX_ERROR;
@@ -548 +552 @@
     length = strlen(napiMount) - 9;
     if(length > extFileLen){
-      NXIReportError(NXpData,"ERROR: internal errro with external linking");
+      NXReportError("ERROR: internal errro with external linking");
       return NXBADURL;
     }
@@ -558 +562 @@
     length = path - pPtr;
     if(length > extFileLen){
-      NXIReportError(NXpData,"ERROR: internal errro with external linking");
+      NXReportError("ERROR: internal errro with external linking");
       return NXBADURL;
     }
@@ -564 +568 @@
     length = strlen(path-1);
     if(length > extPathLen){
-      NXIReportError(NXpData,"ERROR: internal error with external linking");
+      NXReportError("ERROR: internal error with external linking");
       return NXBADURL;
     }
@@ -726 +730 @@
     if (datalen > 1 && iType != NX_CHAR)
     {
-        NXIReportError(NXpData,"NXputattr: numeric arrays are not allowed as attributes - only character strings and single numbers");
+        NXReportError("NXputattr: numeric arrays are not allowed as attributes - only character strings and single numbers");
         return NX_ERROR;
     }
@@ -775 +779 @@
     if(status != NX_OK)
     {
-      NXIReportError(NXpData,"ERROR: item not linked");
+      NXReportError("ERROR: item not linked");
       return NX_ERROR;
     }
@@ -827 +831 @@
       }
       else {
-        NXIReportError (NXpData,
+        NXReportError(
                         "ERROR: NXmalloc - unknown data type in array");
         return NX_ERROR;
@@ -841 +845 @@
   {
     if (data == NULL) {
-       NXIReportError (NXpData, "ERROR: passing NULL to NXfree");
+       NXReportError( "ERROR: passing NULL to NXfree");
        return NX_ERROR;
     }
     if (*data == NULL) {
-       NXIReportError (NXpData,"ERROR: passing already freed pointer to NXfree");
+       NXReportError("ERROR: passing already freed pointer to NXfree");
        return NX_ERROR;
     }
@@ -1312 +1316 @@
   }
   snprintf(pBueffel,255,"ERROR: NXopenpath cannot step into %s",name);
-  NXIReportError (NXpData, pBueffel);
+  NXReportError( pBueffel);
   return NX_ERROR;              
 }
@@ -1348 +1352 @@
   }
   snprintf(pBueffel,255,"ERROR: NXopenpath cannot step into %s",name);
-  NXIReportError (NXpData, pBueffel);
+  NXReportError( pBueffel);
   return NX_ERROR;              
 }
@@ -1360 +1364 @@
   if(hfil == NULL || path == NULL)
   {
-    NXIReportError(NXpData,
+    NXReportError(
      "ERROR: NXopendata needs both a file handle and a path string");
     return NX_ERROR;
@@ -1368 +1372 @@
   if(status != NX_OK)
   {
-    NXIReportError (NXpData, 
+    NXReportError( 
                     "ERROR: NXopendata failed to move down in hierarchy");
     return status;
@@ -1397 +1401 @@
   if(hfil == NULL || path == NULL)
   {
-    NXIReportError(NXpData,
+    NXReportError(
      "ERROR: NXopendata needs both a file handle and a path string");
     return NX_ERROR;
@@ -1405 +1409 @@
   if(status != NX_OK)
   {
-    NXIReportError (NXpData, 
+    NXReportError( 
                     "ERROR: NXopendata failed to move down in hierarchy");
     return status;
@@ -1459 +1463 @@
     time_buffer = (char *)malloc(64*sizeof(char));
     if(!time_buffer){
-      NXIReportError(NXpData,"Failed to allocate buffer for time data");
+      NXReportError("Failed to allocate buffer for time data");
       return NULL;
     }
@@ -1482 +1486 @@
     else
     {
-        NXIReportError (NXpData, 
+        NXReportError( 
         "Your gmtime() function does not work ... timezone information will be incorrect\n");
         gmt_offset = 0;
@@ -1584 +1588 @@
         "ERROR: Cannot allocate space for array rank of %d in NXfmakedata", 
                 *pRank);
-        NXIReportError (NXpData, buffer);
+        NXReportError( buffer);
         return NX_ERROR;
     }
@@ -1615 +1619 @@
       "ERROR: Cannot allocate space for array rank of %d in NXfcompmakedata", 
          *pRank);
-        NXIReportError (NXpData, buffer);
+        NXReportError( buffer);
         return NX_ERROR;
     }

trunk/src/napi4.c

@@ -127 +127 @@
       pArray = (int32 *) malloc (iN * sizeof (int32));
       if (!pArray) {
-        NXIReportError (NXpData, "ERROR: out of memory in NXIFindVgroup");
+        NXReportError( "ERROR: out of memory in NXIFindVgroup");
         return NX_EOD;
       }
@@ -187 +187 @@
       i = SDfileinfo (self->iSID, &iN, &iA);
       if (i < 0) {
-        NXIReportError (NXpData, "ERROR: failure to read file information");
+        NXReportError( "ERROR: failure to read file information");
         return NX_EOD;
       }
@@ -246 +246 @@
           (int32 *) malloc (self->iStack[iStackPtr].iNDir * sizeof (int32) + 1);
       if (!self->iStack[iStackPtr].iRefDir) {
-        NXIReportError (NXpData, "ERROR: out of memory in NXIInitDir");
+        NXReportError( "ERROR: out of memory in NXIInitDir");
         return NX_EOD;
       }
@@ -261 +261 @@
       if ((!self->iStack[iStackPtr].iRefDir) ||
           (!self->iStack[iStackPtr].iTagDir)) {
-        NXIReportError (NXpData, "ERROR: out of memory in NXIInitDir");
+        NXReportError( "ERROR: out of memory in NXIInitDir");
         return NX_EOD;
       }
@@ -315 +315 @@
     }
     if (iRet < 0) {
-      NXIReportError (NXpData, "ERROR: HDF cannot read attribute numbers");
+      NXReportError( "ERROR: HDF cannot read attribute numbers");
       pFile->iAtt.iNDir = 0;
       return NX_ERROR;
@@ -354 +354 @@
               strncat(buffer,pText,bufLen-strlen(buffer));
           } else {
-              NXIReportError (NXpData, "ERROR: NXIbuildPath cannot get vgroup name");
+              NXReportError( "ERROR: NXIbuildPath cannot get vgroup name");
           }
           Vdetach(groupID);
@@ -360 +360 @@
       else
       {
-          NXIReportError (NXpData, "ERROR: NXIbuildPath cannot attach to vgroup");
+          NXReportError( "ERROR: NXIbuildPath cannot attach to vgroup");
       }
     }
@@ -370 +370 @@
       else
       {
-          NXIReportError (NXpData, "ERROR: NXIbuildPath cannot read SDS");
+          NXReportError( "ERROR: NXIbuildPath cannot read SDS");
       }
     }
@@ -409 +409 @@
     pNew = (pNexusFile) malloc (sizeof (NexusFile));
     if (!pNew) {
-      NXIReportError (NXpData, "ERROR: no memory to create File datastructure");
+      NXReportError( "ERROR: no memory to create File datastructure");
       return NX_ERROR;
     }
@@ -422 +422 @@
       if ( (file_id = Hopen(filename, am1, 0)) == -1 ) {
         sprintf (pBuffer, "ERROR: cannot open file_a: %s", filename);
-        NXIReportError (NXpData, pBuffer);
+        NXReportError( pBuffer);
         free (pNew);
         return NX_ERROR;
@@ -433 +433 @@
       if (Hclose(file_id) == -1) {
         sprintf (pBuffer, "ERROR: cannot close file: %s", filename);
-        NXIReportError (NXpData, pBuffer);
+        NXReportError( pBuffer);
         free (pNew);
         return NX_ERROR;
@@ -445 +445 @@
     if (pNew->iSID <= 0) {
       sprintf (pBuffer, "ERROR: cannot open file_b: %s", filename);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       free (pNew);
       return NX_ERROR;
@@ -455 +455 @@
     if (am != NXACC_READ) {
       if (SDsetattr(pNew->iSID, "NeXus_version", DFNT_CHAR8, strlen(NEXUS_VERSION), NEXUS_VERSION) < 0) {
-          NXIReportError (NXpData, "ERROR: HDF failed to store NeXus_version attribute ");
+          NXReportError( "ERROR: HDF failed to store NeXus_version attribute ");
           return NX_ERROR;
       }
       Hgetlibversion(&lmajor, &lminor, &lrelease, HDF_VERSION); 
       if (SDsetattr(pNew->iSID, "HDF_version", DFNT_CHAR8, strlen(HDF_VERSION), HDF_VERSION) < 0) {
-          NXIReportError (NXpData, "ERROR: HDF failed to store HDF_version attribute ");
+          NXReportError( "ERROR: HDF failed to store HDF_version attribute ");
           return NX_ERROR;
       }
@@ -468 +468 @@
     if (am == NXACC_CREATE || am == NXACC_CREATE4) {
       if (SDsetattr(pNew->iSID, "file_name", DFNT_CHAR8, strlen(filename), (char*)filename) < 0) {
-        NXIReportError (NXpData, "ERROR: HDF failed to store file_name attribute ");
+        NXReportError( "ERROR: HDF failed to store file_name attribute ");
         return NX_ERROR;
       }
@@ -474 +474 @@
         if (SDsetattr(pNew->iSID, "file_time", DFNT_CHAR8, 
                       strlen(time_puffer), time_puffer) < 0) {
-          NXIReportError (NXpData, 
+          NXReportError( 
                           "ERROR: HDF failed to store file_time attribute ");
           free(time_puffer);
@@ -506 +506 @@
     if (pNew->iVID <= 0) {
       sprintf (pBuffer, "ERROR: cannot open file_c: %s", filename);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       free (pNew);
       return NX_ERROR;
@@ -535 +535 @@
     }
     if (iRet < 0) {
-      NXIReportError (NXpData, "ERROR: ending access to SDS");
+      NXReportError( "ERROR: ending access to SDS");
     }
     /* close the SDS and Vgroup API's */
@@ -541 +541 @@
     iRet = SDend (pFile->iSID);
     if (iRet < 0) {
-      NXIReportError (NXpData, "ERROR: HDF cannot close SDS interface");
+      NXReportError( "ERROR: HDF cannot close SDS interface");
     }
     iRet = Hclose (pFile->iVID);
     if (iRet < 0) {
-      NXIReportError (NXpData, "ERROR: HDF cannot close HDF file");
+      NXReportError( "ERROR: HDF cannot close HDF file");
     }
     /* release memory */
@@ -572 +572 @@
       sprintf (pBuffer, "ERROR: Vgroup %s, class %s already exists", 
                         name, nxclass);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -579 +579 @@
     iNew = Vattach (pFile->iVID, -1, "w");
     if (iNew < 0) {
-      NXIReportError (NXpData, "ERROR: HDF could not create Vgroup");
+      NXReportError( "ERROR: HDF could not create Vgroup");
       return NX_ERROR;
     }
@@ -592 +592 @@
     Vdetach (iNew);
     if (iRet < 0) {
-      NXIReportError (NXpData, "ERROR: HDF failed to insert Vgroup");
+      NXReportError( "ERROR: HDF failed to insert Vgroup");
       return NX_ERROR;
     }
@@ -611 +611 @@
     if (iRef < 0) {
       sprintf (pBuffer, "ERROR: Vgroup %s, class %s NOT found", name, nxclass);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -684 +684 @@
     if ((iNew = NXIFindSDS (fid, name))>=0) {
       sprintf (pBuffer, "ERROR: SDS %s already exists at this level", name);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -726 +726 @@
     else
     {
-      NXIReportError (NXpData, "ERROR: invalid type in NX4makedata");
+      NXReportError( "ERROR: invalid type in NX4makedata");
       return NX_ERROR;
     }
@@ -733 +733 @@
       sprintf (pBuffer, "ERROR: invalid rank specified for SDS %s",
                name);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -746 +746 @@
                  "ERROR: invalid dimension %d, value %d given for SDS %s",
                  i, dimensions[i], name);
-        NXIReportError (NXpData, pBuffer);
+        NXReportError( pBuffer);
         return NX_ERROR;
       }
@@ -767 +767 @@
     if (pFile->iCurrentVG == 0) {
       sprintf(pBuffer, "ERROR: SDS creation at root level is not permitted");
-      NXIReportError(NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -777 +777 @@
       sprintf (pBuffer, "ERROR: cannot create SDS %s, check arguments",
                name);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -786 +786 @@
     iRet = SDendaccess (iNew);
     if (iRet < 0) {
-      NXIReportError (NXpData, "ERROR: HDF cannot end access to SDS");
+      NXReportError( "ERROR: HDF cannot end access to SDS");
       return NX_ERROR;
     }
@@ -815 +815 @@
     if ((iNew = NXIFindSDS (fid, name))>=0) {
       sprintf (pBuffer, "ERROR: SDS %s already exists at this level", name);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -857 +857 @@
     else
     {
-      NXIReportError (NXpData, "ERROR: invalid datatype in NX4compmakedata");
+      NXReportError( "ERROR: invalid datatype in NX4compmakedata");
       return NX_ERROR;
     }
@@ -864 +864 @@
       sprintf (pBuffer, "ERROR: invalid rank specified for SDS %s",
                name);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -877 +877 @@
                  "ERROR: invalid dimension %d, value %d given for SDS %s",
                  i, dimensions[i], name);
-        NXIReportError (NXpData, pBuffer);
+        NXReportError( pBuffer);
         return NX_ERROR;
       }
@@ -898 +898 @@
     if (pFile->iCurrentVG == 0) {
       sprintf(pBuffer, "ERROR: SDS creation at root level is not permitted");
-      NXIReportError(NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -908 +908 @@
       sprintf (pBuffer, "ERROR: cannot create SDS %s, check arguments",
                name);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -926 +926 @@
       if (iRet < 0) 
       {
-        NXIReportError (NXpData, "LZW-Compression failure!");
+        NXReportError( "LZW-Compression failure!");
         return NX_ERROR;
       } 
@@ -935 +935 @@
       if (iRet < 0) 
         {
-          NXIReportError (NXpData, "RLE-Compression failure!");
+          NXReportError( "RLE-Compression failure!");
           return NX_ERROR;
         }   
@@ -945 +945 @@
       if (iRet < 0) 
         {
-          NXIReportError (NXpData, "HUF-Compression failure!");
+          NXReportError( "HUF-Compression failure!");
           return NX_ERROR;
         }  
@@ -955 +955 @@
     else 
     {
-      NXIReportError (NXpData, "Unknown compression method!");
+      NXReportError( "Unknown compression method!");
       return NX_ERROR; 
     }
@@ -964 +964 @@
     iRet = SDendaccess (iNew);
     if (iRet < 0) {
-      NXIReportError (NXpData, "ERROR: HDF cannot end access to SDS");
+      NXReportError( "ERROR: HDF cannot end access to SDS");
       return NX_ERROR;
     }
@@ -989 +989 @@
     /* check if there is an SDS open */
     if (pFile->iCurrentSDS == 0) {
-      NXIReportError (NXpData, "ERROR: no SDS open");
+      NXReportError( "ERROR: no SDS open");
       return NX_ERROR;
     }
@@ -1036 +1036 @@
     if (iRet < 0) {
       sprintf (pError, "ERROR: failure to compress data to %s", pBuffer);
-      NXIReportError (NXpData, pError);
+      NXReportError( pError);
       return NX_ERROR;
     }
@@ -1058 +1058 @@
     if (iNew < 0) {
       sprintf (pBuffer, "ERROR: SDS %s not found at this level", name);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -1067 +1067 @@
       iRet = SDendaccess (pFile->iCurrentSDS);
       if (iRet < 0) {
-        NXIReportError (NXpData, "ERROR: HDF cannot end access to SDS");
+        NXReportError( "ERROR: HDF cannot end access to SDS");
       }
     }
@@ -1086 +1086 @@
 
     if (pFile->iCurrentSDS < 0) {
-      NXIReportError (NXpData, "ERROR: HDF error opening SDS");
+      NXReportError( "ERROR: HDF error opening SDS");
       pFile->iCurrentSDS = 0;
       return NX_ERROR;
@@ -1107 +1107 @@
       pFile->iCurrentSDS = 0;
       if (iRet < 0) {
-        NXIReportError (NXpData, "ERROR: HDF cannot end access to SDS");
+        NXReportError( "ERROR: HDF cannot end access to SDS");
         return NX_ERROR;
       }
     } else {
-      NXIReportError (NXpData, "ERROR: no SDS open --> nothing to do");
+      NXReportError( "ERROR: no SDS open --> nothing to do");
       return NX_ERROR;
     }
@@ -1133 +1133 @@
     /* check if there is an SDS open */
     if (pFile->iCurrentSDS == 0) {
-      NXIReportError (NXpData, "ERROR: no SDS open");
+      NXReportError( "ERROR: no SDS open");
       return NX_ERROR;
     }
@@ -1150 +1150 @@
       /* HEprint(stdout,0); */
       sprintf (pError, "ERROR: failure to write data to %s", pBuffer);
-      NXIReportError (NXpData, pError);
+      NXReportError( pError);
       return NX_ERROR;
     }
@@ -1203 +1203 @@
     else
     {
-      NXIReportError (NXpData, "ERROR: Invalid data type for HDF attribute");
+      NXReportError( "ERROR: Invalid data type for HDF attribute");
       return NX_ERROR;
     }
@@ -1223 +1223 @@
     iType = type;
     if (iRet < 0) {
-      NXIReportError (NXpData, "ERROR: HDF failed to store attribute ");
+      NXReportError( "ERROR: HDF failed to store attribute ");
       return NX_ERROR;
     }
@@ -1246 +1246 @@
     /* check if there is an SDS open */
     if (pFile->iCurrentSDS == 0) {
-      NXIReportError (NXpData, "ERROR: no SDS open");
+      NXReportError( "ERROR: no SDS open");
       return NX_ERROR;
     }
@@ -1280 +1280 @@
     /* deal with HDF errors */
     if (iRet < 0) {
-      NXIReportError (NXpData, "ERROR: writing slab failed");
+      NXReportError( "ERROR: writing slab failed");
       return NX_ERROR;
     }
@@ -1428 +1428 @@
     iRet = Hfidinquire(pFile->iVID,&pFileName,&access,&dummy);
     if (iRet < 0) {
-      NXIReportError (NXpData, 
+      NXReportError( 
         "ERROR: Failed to inquire file name for HDF file");
       return NX_ERROR;
@@ -1437 +1437 @@
       ac = NXACC_RDWR;
     } else {
-      NXIReportError (NXpData, 
+      NXReportError( 
         "ERROR: NX4flush failed to determine file access mode");
       return NX_ERROR;
@@ -1443 +1443 @@
     pCopy = (char *)malloc((strlen(pFileName)+10)*sizeof(char));
     if(!pCopy) {
-      NXIReportError (NXpData, 
+      NXReportError( 
         "ERROR: Failed to allocate data for filename copy");
       return NX_ERROR;
@@ -1456 +1456 @@
       iRefs = (int *)malloc(iStack*sizeof(int));
       if(!iRefs){
-        NXIReportError (NXpData, 
+        NXReportError( 
         "ERROR: Failed to allocate data for hierarchy copy");
         return NX_ERROR;
@@ -1508 +1508 @@
       iRet = NXIInitDir (pFile);
       if (iRet < 0) {
-        NXIReportError (NXpData,
+        NXReportError(
                         "ERROR: no memory to store directory info");
         return NX_EOD;
@@ -1525 +1525 @@
                        pFile->iStack[iStackPtr].iRefDir[iCurDir], "r");
       if (iTemp < 0) {
-        NXIReportError (NXpData, "ERROR: HDF cannot attach to Vgroup");
+        NXReportError( "ERROR: HDF cannot attach to Vgroup");
         return NX_ERROR;
       }
@@ -1539 +1539 @@
                          pFile->iStack[iStackPtr].iRefDir[iCurDir], "r");
         if (iTemp < 0) {
-          NXIReportError (NXpData, "ERROR: HDF cannot attach to Vgroup");
+          NXReportError( "ERROR: HDF cannot attach to Vgroup");
           return NX_ERROR;
         }
@@ -1588 +1588 @@
     /* check if there is an SDS open */
     if (pFile->iCurrentSDS == 0) {
-      NXIReportError (NXpData, "ERROR: no SDS open");
+      NXReportError( "ERROR: no SDS open");
       return NX_ERROR;
     }
@@ -1613 +1613 @@
     /* check if there is an SDS open */
     if (pFile->iCurrentSDS == 0) {
-      NXIReportError (NXpData, "ERROR: no SDS open");
+      NXReportError( "ERROR: no SDS open");
       return NX_ERROR;
     }
@@ -1645 +1645 @@
     /* check if there is an SDS open */
     if (pFile->iCurrentSDS == 0) {
-      NXIReportError (NXpData, "ERROR: no SDS open");
+      NXReportError( "ERROR: no SDS open");
       return NX_ERROR;
     }
@@ -1714 +1714 @@
     }
     if (iRet < 0) {
-      NXIReportError (NXpData, "ERROR: HDF cannot read attribute info");
+      NXReportError( "ERROR: HDF cannot read attribute info");
       return NX_ERROR;
     }
@@ -1792 +1792 @@
     if (iNew < 0) {
       sprintf (pBuffer, "ERROR: attribute %s not found", name);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -1809 +1809 @@
     if (iRet < 0) {
       sprintf (pBuffer, "ERROR: HDF could not read attribute info");
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -1819 +1819 @@
     pData = (void *) malloc (iLen);
     if (!pData) {
-      NXIReportError (NXpData, "ERROR: allocating memory in NXgetattr");
+      NXReportError( "ERROR: allocating memory in NXgetattr");
       return NX_ERROR;
     }
@@ -1836 +1836 @@
     if (iRet < 0) {
       sprintf (pBuffer, "ERROR: HDF could not read attribute data");
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -1876 +1876 @@
     }
     if (iRet < 0) {
-      NXIReportError (NXpData, "NX_ERROR: HDF cannot read attribute numbers");
+      NXReportError( "NX_ERROR: HDF cannot read attribute numbers");
       *iN = 0;
       return NX_ERROR;
@@ -1971 +1971 @@
     iRet = NXIInitDir (pFile);
     if (iRet < 0) {
-      NXIReportError (NXpData,"NX_ERROR: no memory to store directory info");
+      NXReportError("NX_ERROR: no memory to store directory info");
       return NX_EOD;
     }

trunk/src/napi5.c

@@ -151 +151 @@
     pNew = (pNexusFile5) malloc (sizeof (NexusFile5));
     if (!pNew) {
-      NXIReportError (NXpData,"ERROR: no memory to create File datastructure");
+      NXReportError("ERROR: no memory to create File datastructure");
       return NX_ERROR;
     }
@@ -183 +183 @@
     if (pNew->iFID <= 0) {
       sprintf (pBuffer, "ERROR: cannot open file: %s", filename);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       free (pNew);
       return NX_ERROR;
@@ -208 +208 @@
         if (attr1<0)
         {
-          NXIReportError (NXpData, 
+          NXReportError( 
                          "ERROR: HDF failed to store NeXus_version attribute ");
           return NX_ERROR;
@@ -214 +214 @@
         if (H5Awrite(attr1, aid1,NEXUS_VERSION)<0)
         {
-          NXIReportError (NXpData, 
+          NXReportError( 
                          "ERROR: HDF failed to store NeXus_version attribute ");
           return NX_ERROR;
@@ -234 +234 @@
         if (attr1 < 0)
         {
-          NXIReportError (NXpData, 
+          NXReportError( 
                           "ERROR: HDF failed to store file_name attribute ");
           return NX_ERROR;
@@ -240 +240 @@
         if (H5Awrite(attr1, aid1, (char*)filename) < 0)
         {
-          NXIReportError (NXpData, 
+          NXReportError( 
                           "ERROR: HDF failed to store file_name attribute ");
           return NX_ERROR;
@@ -256 +256 @@
         if (attr1 < 0)
         {
-          NXIReportError (NXpData, 
+          NXReportError( 
                           "ERROR: HDF failed to store file_name attribute ");
           return NX_ERROR;
@@ -262 +262 @@
         if (H5Awrite(attr1, aid1, (char*)version_nr) < 0)
         {
-          NXIReportError (NXpData, 
+          NXReportError( 
                           "ERROR: HDF failed to store file_name attribute ");
           return NX_ERROR;
@@ -278 +278 @@
           if (attr1 < 0)
           {
-              NXIReportError (NXpData, 
+              NXReportError( 
                           "ERROR: HDF failed to store file_time attribute ");
               free(time_buffer);
@@ -285 +285 @@
           if (H5Awrite(attr1, aid1, time_buffer) < 0)
           {
-              NXIReportError (NXpData, 
+              NXReportError( 
                           "ERROR: HDF failed to store file_time attribute ");
               free(time_buffer);
@@ -342 +342 @@
 
     if (iRet < 0) {
-      NXIReportError (NXpData, "ERROR: HDF cannot close HDF file");
+      NXReportError( "ERROR: HDF cannot close HDF file");
     }
     /* release memory */
@@ -380 +380 @@
     }   
     if (iRet < 0) {
-      NXIReportError (NXpData, "ERROR: HDF could not create Group");
+      NXReportError( "ERROR: HDF could not create Group");
       return NX_ERROR;
     }
@@ -390 +390 @@
     if (attr1 < 0)
        {
-       NXIReportError (NXpData, "ERROR: HDF failed to store class name!");
+       NXReportError( "ERROR: HDF failed to store class name!");
        return NX_ERROR;
        }
     if (H5Awrite(attr1, aid1, (char*)nxclass) < 0)
       {
-      NXIReportError (NXpData, "ERROR: HDF failed to store class name!");
+      NXReportError( "ERROR: HDF failed to store class name!");
       return NX_ERROR;
       }
@@ -437 +437 @@
     if (iRet < 0) {
       sprintf (pBuffer, "ERROR: Group %s does not exist!", pFile->name_tmp);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;  
     }
@@ -449 +449 @@
         iRet=H5Aiterate(pFile->iCurrentG,NULL,attr_check,NULL);
         if (iRet < 0) {
-          NXIReportError (NXpData, "ERROR iterating through group!");
+          NXReportError( "ERROR iterating through group!");
           return NX_ERROR;  
         } else if (iRet == 1) {
@@ -455 +455 @@
         } else {
          /* no group attribute available */
-         NXIReportError (NXpData, "No group attribute available");
+         NXReportError( "No group attribute available");
          return NX_ERROR;
         }
@@ -462 +462 @@
         if (attr1 < 0)
         {
-              NXIReportError (NXpData, "Error opening NX_class group attribute!");
+              NXReportError( "Error opening NX_class group attribute!");
               return NX_ERROR; 
         }
@@ -471 +471 @@
               /* test OK */
         } else {
-              NXIReportError (NXpData, "Group class is not identical!");
+              NXReportError( "Group class is not identical!");
               iRet = H5Tclose(atype);
               iRet = H5Aclose(attr1); 
@@ -600 +600 @@
     else
     {
-      NXIReportError (NXpData, "ERROR: nxToHDF5Type: unknown type");
+      NXReportError( "ERROR: nxToHDF5Type: unknown type");
       type = -1;
     }
@@ -630 +630 @@
           sprintf (pBuffer, "ERROR: no group open for makedata on %s",
               name);
-          NXIReportError (NXpData, pBuffer);
+          NXReportError( pBuffer);
           return NX_ERROR;
       }
@@ -648 +648 @@
           sprintf (pBuffer, "ERROR: invalid rank specified %s",
               name);
-          NXIReportError (NXpData, pBuffer);
+          NXReportError( pBuffer);
           return NX_ERROR;
       }
@@ -662 +662 @@
                   "ERROR: invalid dimension %d, value %d given for Dataset %s",
                   i, dimensions[i], name);
-              NXIReportError (NXpData, pBuffer);
+              NXReportError( pBuffer);
               return NX_ERROR;
           }
@@ -727 +727 @@
           if (iNew < 0) 
           {
-              NXIReportError (NXpData, "ERROR: Size of chunks could not be set!");
+              NXReportError( "ERROR: Size of chunks could not be set!");
               return NX_ERROR;
           }
@@ -741 +741 @@
               if (iNew < 0) 
               {
-                  NXIReportError (NXpData, "ERROR: Size of chunks could not be set!");
+                  NXReportError( "ERROR: Size of chunks could not be set!");
                   return NX_ERROR;
               }
@@ -757 +757 @@
           if (iNew < 0) 
           {
-              NXIReportError (NXpData, "ERROR: Size of chunks could not be set!");
+              NXReportError( "ERROR: Size of chunks could not be set!");
               return NX_ERROR;
           }
@@ -765 +765 @@
       else 
       {
-          NXIReportError (NXpData, 
+          NXReportError( 
               "HDF5 doesn't support selected compression method! Dataset was saved without compression");
           iRet = H5Dcreate (pFile->iCurrentG, (char*)name, datatype1, dataspace, H5P_DEFAULT); 
@@ -771 +771 @@
       if (iRet < 0) 
       {
-          NXIReportError (NXpData, "ERROR: Creating chunked dataset failed!");
+          NXReportError( "ERROR: Creating chunked dataset failed!");
           return NX_ERROR;
       } 
@@ -786 +786 @@
               sprintf (pBuffer, "ERROR: cannot create Dataset %s, check arguments",
                   name);
-              NXIReportError (NXpData, pBuffer);
+              NXReportError( pBuffer);
               return NX_ERROR;
           }
@@ -800 +800 @@
       if (iRet < 0)
       {
-          NXIReportError (NXpData, "ERROR: HDF cannot close Dataset");
+          NXReportError( "ERROR: HDF cannot close Dataset");
           return NX_ERROR;
       }
@@ -854 +854 @@
     if (pFile->iCurrentD < 0) {
       sprintf (pBuffer, "ERROR: Dataset %s not found at this level", name);
-      NXIReportError (NXpData, pBuffer);
+      NXReportError( pBuffer);
       return NX_ERROR;
     }
@@ -860 +860 @@
     pFile->iCurrentT = H5Dget_type(pFile->iCurrentD);
     if (pFile->iCurrentT < 0) {
-      NXIReportError (NXpData, "ERROR:HDF error opening Dataset");
+      NXReportError( "ERROR:HDF error opening Dataset");
       pFile->iCurrentT=0;
       return NX_ERROR;
@@ -867 +867 @@
     pFile->iCurrentS = H5Dget_space(pFile->iCurrentD);
     if (pFile->iCurrentS < 0) {
-      NXIReportError (NXpData, "ERROR:HDF error opening Dataset");
+      NXReportError( "ERROR:HDF error opening Dataset");
       pFile->iCurrentS=0;
       return NX_ERROR;
@@ -890 +890 @@
     iRet = H5Dclose(pFile->iCurrentD);
     if (iRet < 0) {
-        NXIReportError (NXpData, "ERROR: HDF cannot end access to Dataset");
+        NXReportError( "ERROR: HDF cannot end access to Dataset");
         return NX_ERROR;
      }
@@ -915 +915 @@
     if (iRet < 0) {
       snprintf (pError,511, "ERROR: failure to write data");
-      NXIReportError (NXpData, pError);
+      NXReportError( pError);
       return NX_ERROR;
     }
@@ -969 +969 @@
       iRet=H5Adelete(vid,name);
       if (iRet<0) {
-        NXIReportError (NXpData, "ERROR: Old attribute cannot be removed! ");
+        NXReportError( "ERROR: Old attribute cannot be removed! ");
         killAttVID(pFile,vid);
         return NX_ERROR;
@@ -976 +976 @@
     attr1 = H5Acreate(vid, name, aid1, aid2, H5P_DEFAULT);
     if (attr1 < 0) {
-      NXIReportError (NXpData, "ERROR: Attribute cannot created! ");
+      NXReportError( "ERROR: Attribute cannot created! ");
       killAttVID(pFile,vid);
       return NX_ERROR;
     }   
     if (H5Awrite(attr1,aid1,data) < 0) {
-      NXIReportError (NXpData, "ERROR: HDF failed to store attribute ");
+      NXReportError( "ERROR: HDF failed to store attribute ");
       killAttVID(pFile,vid);
       return NX_ERROR;
@@ -1009 +1009 @@
      /* check if there is an Dataset open */
     if (pFile->iCurrentD == 0) {
-      NXIReportError (NXpData, "ERROR: no dataset open");
+      NXReportError( "ERROR: no dataset open");
       return NX_ERROR;
     }
@@ -1033 +1033 @@
        if (iRet < 0) 
        {
-           NXIReportError (NXpData, "ERROR: extend slab failed");
+           NXReportError( "ERROR: extend slab failed");
            return NX_ERROR;
        }
@@ -1045 +1045 @@
        if (iRet < 0) 
        {
-       NXIReportError (NXpData, "ERROR: selecting slab failed");
+       NXReportError( "ERROR: selecting slab failed");
        return NX_ERROR;
        }
@@ -1053 +1053 @@
        if (iRet < 0)
        {
-           NXIReportError (NXpData, "ERROR: writing slab failed");
+           NXReportError( "ERROR: writing slab failed");
        }
        iRet = H5Sclose(filespace);             
@@ -1063 +1063 @@
        if (iRet < 0) 
        {
-       NXIReportError (NXpData, "ERROR: selecting slab failed");
+       NXReportError( "ERROR: selecting slab failed");
        return NX_ERROR;
        }
@@ -1071 +1071 @@
        if (iRet < 0)
        {
-           NXIReportError (NXpData, "ERROR: writing slab failed");
+           NXReportError( "ERROR: writing slab failed");
        }
    }
@@ -1078 +1078 @@
    if (iRet < 0) 
    {
-      NXIReportError (NXpData, "ERROR: closing slab failed");
+      NXReportError( "ERROR: closing slab failed");
       return NX_ERROR;
    }
@@ -1146 +1146 @@
     if(dataID < 0)
     {
-      NXIReportError(NXpData,"Internal error, path to link does not exist");
+      NXReportError("Internal error, path to link does not exist");
       return NX_ERROR;
     }
@@ -1204 +1204 @@
     else 
     {
-      NXIReportError(NXpData,"Path string to long");
+      NXReportError("Path string to long");
       return NX_ERROR;
     } 
@@ -1232 +1232 @@
     itemName = strrchr(sLink->targetPath,'/');
     if(itemName == NULL){
-      NXIReportError(NXpData,"Bad link structure");
+      NXReportError("Bad link structure");
       return NX_ERROR;
     }
@@ -1250 +1250 @@
     else 
     {
-      NXIReportError(NXpData,"Path string to long");
+      NXReportError("Path string to long");
       return NX_ERROR;
     } 
@@ -1280 +1280 @@
     }
     if (iRet < 0){
-      NXIReportError (NXpData, "ERROR: The object cannot be flushed");
+      NXReportError( "ERROR: The object cannot be flushed");
       return NX_ERROR; 
     }
@@ -1385 +1385 @@
   status = H5Gget_num_objs(loc_id, &numobj);
   if(status < 0) {
-    NXIReportError(NXpData,"Internal error, failed to retrive no of objects");
+    NXReportError("Internal error, failed to retrive no of objects");
     return 0;
   }
@@ -1509 +1509 @@
       if (iPtype == -1)
       {
-          NXIReportError (NXpData, "ERROR: hdf5ToNXtype: invalid type");
+          NXReportError( "ERROR: hdf5ToNXtype: invalid type");
       }
 
@@ -1576 +1576 @@
       if (memtype_id == -1)
       {
-          NXIReportError (NXpData, "ERROR: h5MemType: invalid type");
+          NXReportError( "ERROR: h5MemType: invalid type");
       }
       return memtype_id;
@@ -1650 +1650 @@
            if (grp < 0) {
               sprintf (pBuffer, "ERROR: Group %s does not exist!", ph_name);
-              NXIReportError (NXpData, pBuffer);
+              NXReportError( pBuffer);
               return NX_ERROR;  
            }
@@ -1700 +1700 @@
             free(op_data.iname);
          } 
-         NXIReportError (NXpData, 
+         NXReportError( 
                             "ERROR: Iteration (directory) was not successful");
          return NX_ERROR;              
@@ -1720 +1720 @@
      if (pFile->iCurrentD == 0) 
      {
-        NXIReportError (NXpData, "ERROR: no Dataset open");
+        NXReportError( "ERROR: no Dataset open");
         return NX_ERROR;
      }
@@ -1746 +1746 @@
      if(status < 0)
      {
-        NXIReportError (NXpData, "ERROR: failed to transfer dataset");
+        NXReportError( "ERROR: failed to transfer dataset");
         return NX_ERROR;
 
@@ -1765 +1765 @@
      /* check if there is an Dataset open */
      if (pFile->iCurrentD == 0) {
-       NXIReportError (NXpData, "ERROR: no Dataset open");
+       NXReportError( "ERROR: no Dataset open");
        return NX_ERROR;
      }
@@ -1806 +1806 @@
      if (pFile->iCurrentD == 0) 
        {
-         NXIReportError (NXpData, "ERROR: no Dataset open");
+         NXReportError( "ERROR: no Dataset open");
          return NX_ERROR;
        }
@@ -1839 +1839 @@
       if (iRet < 0) 
         {
-          NXIReportError (NXpData, "ERROR: selecting slab failed");
+          NXReportError( "ERROR: selecting slab failed");
           return NX_ERROR;
         }
@@ -1848 +1848 @@
       if (iRet < 0) 
         {
-          NXIReportError (NXpData, "ERROR: Select memspace failed");
+          NXReportError( "ERROR: Select memspace failed");
           return NX_ERROR;
         }
@@ -1883 +1883 @@
 
         {
-          NXIReportError (NXpData, "ERROR: Reading slab failed");
+          NXReportError( "ERROR: Reading slab failed");
           return NX_ERROR;
         }
@@ -1933 +1933 @@
      intern_idx=-1;
      if (iRet < 0) {
-           NXIReportError (NXpData, "ERROR iterating through attribute list!");
+           NXReportError( "ERROR iterating through attribute list!");
            killAttVID(pFile,vid);
            return NX_ERROR;  
@@ -1998 +1998 @@
        sprintf (pBuffer, "ERROR: attribute %s not found", name);
        killAttVID(pFile,vid);
-       NXIReportError (NXpData, pBuffer);
+       NXReportError( pBuffer);
        return NX_ERROR;
      }
@@ -2022 +2022 @@
      if (iRet < 0) {
        sprintf (pBuffer, "ERROR: HDF could not read attribute data");
-       NXIReportError (NXpData, pBuffer);
+       NXReportError( pBuffer);
        killAttVID(pFile,vid);
        return NX_ERROR;

trunk/src/napiu.c

@@ -104 +104 @@
          else
          {
-                 NXIReportError(NXpData, "Invalid compression option");
+                 NXReportError( "Invalid compression option");
          status = NX_ERROR;
          }

trunk/src/nexus_symbols.txt

@@ -48 +48 @@
 NXMSetError
 NXMSetTError
+NXReportError
 NXIReportError
 NXIprintlink

trunk/src/nxxml.c

@@ -107 +107 @@
     }
     if(testNode == NULL){
-      NXIReportError(NXpData,"Cannot follow broken link");
+      NXReportError("Cannot follow broken link");
       return NULL;
     } else {
@@ -117 +117 @@
 /*==================== file functions ===================================*/
 static void errorCallbackForMxml(const char *txt){
-  NXIReportError(NXpData,(char *)txt);
+  NXReportError((char *)txt);
 }
 /*-----------------------------------------------------------------------*/
@@ -132 +132 @@
   xmlHandle = (pXMLNexus)malloc(sizeof(XMLNexus));
   if(!xmlHandle){
-    NXIReportError(NXpData, "Out of memory allocating XML file handle");
+    NXReportError( "Out of memory allocating XML file handle");
     return NX_ERROR;
   }
@@ -155 +155 @@
     fp = fopen(filename,"r");
     if(fp == NULL){
-      NXIReportError(NXpData,"Failed to open file:");
-      NXIReportError(NXpData,(char *)filename);
+      NXReportError("Failed to open file:");
+      NXReportError((char *)filename);
       free(xmlHandle);
       return NX_ERROR;
@@ -193 +193 @@
     break;
   default:
-    NXIReportError(NXpData,"Bad access parameter specified in NXXopen");
+    NXReportError("Bad access parameter specified in NXXopen");
     return NX_ERROR;
   }
   if(xmlHandle->stack[0].current == NULL){
-      NXIReportError(NXpData,
+      NXReportError(
                      "No NXroot element in XML-file, no NeXus-XML file");
       return NX_ERROR;
@@ -216 +216 @@
     fp = fopen(xmlHandle->filename,"w");
     if(fp == NULL){
-      NXIReportError(NXpData,"Failed to open NeXus XML file for writing");
+      NXReportError("Failed to open NeXus XML file for writing");
       return NX_ERROR;
     }
@@ -238 +238 @@
     fp = fopen(xmlHandle->filename,"w");
     if(fp == NULL){
-      NXIReportError(NXpData,"Failed to open NeXus XML file for writing");
+      NXReportError("Failed to open NeXus XML file for writing");
       return NX_ERROR;
     }
@@ -258 +258 @@
 
   if(isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"Close dataset before trying to create a group");
+    NXReportError("Close dataset before trying to create a group");
     return NX_ERROR;
   }
@@ -265 +265 @@
                             nxclass);
   if(!newGroup){
-    NXIReportError(NXpData,"failed to allocate new group");
+    NXReportError("failed to allocate new group");
     return NX_ERROR;
   }
@@ -318 +318 @@
 
   if(isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"Close dataset before trying to open a group");
+    NXReportError("Close dataset before trying to open a group");
     return NX_ERROR;
   }
@@ -332 +332 @@
   if(!newGroup){
     snprintf(error,1023,"Failed to open %s, %s",name,nxclass);
-    NXIReportError(NXpData,error);
+    NXReportError(error);
     return NX_ERROR;
   }
@@ -385 +385 @@
   typestring = (char *)malloc(132*sizeof(char));
   if(!typestring){
-    NXIReportError(NXpData,"Failed to allocate typestring");
+    NXReportError("Failed to allocate typestring");
     return NULL;
   }
@@ -420 +420 @@
 
   if(isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"Close dataset before trying to create a dataset");
+    NXReportError("Close dataset before trying to create a dataset");
     return NX_ERROR;
   }
@@ -441 +441 @@
     free(typestring);
   } else {
-    NXIReportError(NXpData,"Failed to allocate typestring");
+    NXReportError("Failed to allocate typestring");
     return NX_ERROR;
   }
@@ -460 +460 @@
       newData = (mxml_node_t *)malloc(sizeof(mxml_node_t));
       if(!newData){
-        NXIReportError(NXpData,"Failed to allocate space for dataset");
+        NXReportError("Failed to allocate space for dataset");
         return NX_ERROR;
       }
@@ -469 +469 @@
       newData->value.custom.data = createNXDataset(1,datatype,&one);
       if(!newData->value.custom.data){
-        NXIReportError(NXpData,"Failed to allocate space for dataset");
+        NXReportError("Failed to allocate space for dataset");
         return NX_ERROR;
       }
@@ -496 +496 @@
 
   if(isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"Close dataset before trying to create a dataset");
+    NXReportError("Close dataset before trying to create a dataset");
     return NX_ERROR;
   }
@@ -510 +510 @@
     free(typestring);
   } else {
-    NXIReportError(NXpData,"Failed to allocate typestring");
+    NXReportError("Failed to allocate typestring");
     return NX_ERROR;
   }
@@ -522 +522 @@
     newData = (mxml_node_t *)malloc(sizeof(mxml_node_t));
     if(!newData){
-      NXIReportError(NXpData,"Failed to allocate space for dataset");
+      NXReportError("Failed to allocate space for dataset");
       return NX_ERROR;
     }
@@ -530 +530 @@
     newData->value.custom.data = createNXDataset(rank,datatype,dimensions);
     if(!newData->value.custom.data){
-      NXIReportError(NXpData,"Failed to allocate space for dataset");
+      NXReportError("Failed to allocate space for dataset");
       return NX_ERROR;
     }
@@ -597 +597 @@
   if(!dimsNode){
     snprintf(error,1023,"Failed to open dataset %s",name);
-    NXIReportError(NXpData,error);
+    NXReportError(error);
     return NX_ERROR;
   }
@@ -612 +612 @@
   if(!dataNode){
     snprintf(error,1023,"Failed to open dataset %s",name);
-    NXIReportError(NXpData,error);
+    NXReportError(error);
     return NX_ERROR;
   }
@@ -675 +675 @@
   if(!dataNode){
     snprintf(error,1023,"Failed to open dataset %s",name);
-    NXIReportError(NXpData,error);
+    NXReportError(error);
     return NX_ERROR;
   }
@@ -773 +773 @@
 
   if(!isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"No dataset open");
+    NXReportError("No dataset open");
     return NX_ERROR;
   }
@@ -801 +801 @@
     else
     {
-        NXIReportError(NXpData,"Unable to determine size of character dataset");
+        NXReportError("Unable to determine size of character dataset");
         return NX_ERROR;
     }
@@ -872 +872 @@
 
   if(!isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"No dataset open");
+    NXReportError("No dataset open");
     return NX_ERROR;
   }
@@ -916 +916 @@
 
   if(!isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"No dataset open");
+    NXReportError("No dataset open");
     return NX_ERROR;
   }
@@ -1029 +1029 @@
       free(typestring);
     } else {
-      NXIReportError(NXpData,"Failed to allocate typestring");
+      NXReportError("Failed to allocate typestring");
       return 0;
     }
@@ -1059 +1059 @@
 
   if(!isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"No dataset open");
+    NXReportError("No dataset open");
     return NX_ERROR;
   }
@@ -1067 +1067 @@
   assert(userData != NULL);
   if(userData->type == MXML_OPAQUE){
-    NXIReportError(NXpData,"This API does not support slabs on text data");
+    NXReportError("This API does not support slabs on text data");
     return NX_ERROR;
   }
@@ -1075 +1075 @@
   status = checkAndExtendDataset(current,dataset,iStart,iSize);
   if(status == 0){
-    NXIReportError(NXpData,"Out of memory extending dataset");
+    NXReportError("Out of memory extending dataset");
     return NX_ERROR;
   }
@@ -1081 +1081 @@
   slabData = makeSlabData(dataset, data, iSize);
   if(slabData == NULL){
-    NXIReportError(NXpData,"Failed to allocate slab data");
+    NXReportError("Failed to allocate slab data");
     return NX_ERROR;
   }
@@ -1131 +1131 @@
 
   if(!isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"No dataset open");
+    NXReportError("No dataset open");
     return NX_ERROR;
   }
@@ -1139 +1139 @@
   assert(userData != NULL);
   if(userData->type == MXML_OPAQUE){
-    NXIReportError(NXpData,"This API does not support slabs on text data");
+    NXReportError("This API does not support slabs on text data");
     return NX_ERROR;
   }
@@ -1146 +1146 @@
   slabData = makeSlabData(dataset, data, iSize);
   if(slabData == NULL){
-    NXIReportError(NXpData,"Failed to allocate slab data");
+    NXReportError("Failed to allocate slab data");
     return NX_ERROR;
   }
@@ -1203 +1203 @@
   number = (char *)malloc(132*sizeof(char));
   if(!number){
-    NXIReportError(NXpData,"Failed to allocate attribute number buffer");
+    NXReportError("Failed to allocate attribute number buffer");
     return NULL;
   }
@@ -1273 +1273 @@
   if(isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
     if(strcmp(name,TYPENAME) == 0){
-      NXIReportError(NXpData,"type is a reserved attribute name, rejected");
+      NXReportError("type is a reserved attribute name, rejected");
       return  NX_ERROR;
     }
@@ -1280 +1280 @@
   numberData = formatAttributeData(data,datalen,iType);
   if(numberData == NULL){
-    NXIReportError(NXpData,"This API does not support non number arrays");
+    NXReportError("This API does not support non number arrays");
     return NX_ERROR;
   } else {
@@ -1306 +1306 @@
   if(!attribute){
     snprintf(error,1023,"Attribute %s not found", name);
-    NXIReportError(NXpData,error);
+    NXReportError(error);
     return NX_ERROR;
   }
@@ -1325 +1325 @@
       attData = strchr(attribute,(int)':');
       if(attData == NULL){
-        NXIReportError(NXpData,"ERROR: bad attribute string, : missing");
+        NXReportError("ERROR: bad attribute string, : missing");
         return NX_ERROR;
       }
@@ -1480 +1480 @@
     linkName = mxmlElementGetAttr(next,"name");
     if(target == NULL){
-      NXIReportError(NXpData,"Corrupted file, NAPIlink without target");
+      NXReportError("Corrupted file, NAPIlink without target");
       return NX_ERROR;
     }
     next = getLinkTarget(xmlHandle,target);
     if(next == NULL){
-      NXIReportError(NXpData,"Corrupted file, broken link");
+      NXReportError("Corrupted file, broken link");
       return NX_ERROR;
     }
@@ -1497 +1497 @@
         snprintf(pBueffel,255,"Corrupted file, userData for %s not found",
                  name);
-      NXIReportError(NXpData,pBueffel);
+      NXReportError(pBueffel);
       return NX_ERROR;
     }
@@ -1529 +1529 @@
 
   if(isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"Cannot search datasets");
+    NXReportError("Cannot search datasets");
     return NX_ERROR;
   }
@@ -1618 +1618 @@
 
   if(isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"No group open");
+    NXReportError("No group open");
     return NX_ERROR;
   } 
@@ -1745 +1745 @@
   path = (mxml_node_t **)malloc(NXMAXSTACK*sizeof(mxml_node_t *));
   if(path == NULL){
-    NXIReportError(NXpData,"ERROR: out of memory following link path");
+    NXReportError("ERROR: out of memory following link path");
     return NULL;
   }
@@ -1787 +1787 @@
   linkPath = findLinkPath(current);
   if(!linkPath){
-    NXIReportError(NXpData,"Failed to allocate link path string");
+    NXReportError("Failed to allocate link path string");
     return NX_ERROR;
   }
@@ -1804 +1804 @@
 
   if(isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"No group open");
+    NXReportError("No group open");
     return NX_ERROR;
   } 
@@ -1815 +1815 @@
   linkPath = findLinkPath(current);
   if(!linkPath){
-    NXIReportError(NXpData,"Failed to allocate link path string");
+    NXReportError("Failed to allocate link path string");
     return NX_ERROR;
   }
@@ -1844 +1844 @@
 
   if(isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"No group to link to open");
+    NXReportError("No group to link to open");
     return NX_ERROR;
   } 
@@ -1850 +1850 @@
   linkNode = mxmlNewElement(current,"NAPIlink");
   if(!linkNode){
-    NXIReportError(NXpData,"Failed to allocate new link element");
+    NXReportError("Failed to allocate new link element");
     return NX_ERROR;
   }
@@ -1871 +1871 @@
 
   if(isDataNode(xmlHandle->stack[xmlHandle->stackPointer].current)){
-    NXIReportError(NXpData,"No group to link to open");
+    NXReportError("No group to link to open");
     return NX_ERROR;
   } 
@@ -1877 +1877 @@
   linkNode = mxmlNewElement(current,"NAPIlink");
   if(!linkNode){
-    NXIReportError(NXpData,"Failed to allocate new link element");
+    NXReportError("Failed to allocate new link element");
     return NX_ERROR;
   }
@@ -1900 +1900 @@
 int  NXXcompress(NXhandle fid, int comp){
   /* that will throw an exception in the Java API, errors have to be fatal */
-  /* NXIReportError(NXpData,"NXcompress is deprecated, IGNORED"); */
+  /* NXReportError("NXcompress is deprecated, IGNORED"); */
   return NX_OK;
 }