Diff from tags/4.2.0@1896 to tags/4.2.1@1896 – NeXus Data Format Library and Applications

tags/4.2.1/contrib/bindings/Makefile.am

r1896	r1896
34	34	PYSUB = python
35	35	endif
36		SUBDIRS = $(~~JAVASUB) $(PY~~SUB)
	36	SUBDIRS = $(PYSUB) # $(JAVASUB)

tags/4.2.1/acinclude.m4

                       r1896
     fi
   ])
+AC_DEFUN([AC_CHECK_PYTHON_MODULE],
+[
+    if test -z "$PYTHON"; then PYTHON="python"; fi
+    AC_MSG_CHECKING(for python module $1)
+    $PYTHON -c "import $1" 2>/dev/null
+    if test $? -eq 0; then
+        eval PYTHON_$1=1
+        eval PYTHON_$1_found="yes"
+        AC_MSG_RESULT(found)
+    else
+        eval PYTHON_$1=0
+        eval PYTHON_$1_found="no"
+        AC_MSG_RESULT(not found)
+    fi
+    AC_SUBST(PYTHON_$1)
+])

tags/4.2.1/Makefile.am

                       r1896
 #  NeXus - Neutron & X-ray Common Data Format
+#
-#  $Id$
+#
 #  Top level Makefile for coordinating NeXus build
+#
 …
 #  MA  02111-1307  USA
+#
 #  For further information, see <http://www.neutron.anl.gov/NeXus/>
+#  For further information, see <http://www.nexusformat.org>
+#
 #  @configure_input@
 …
 CONTRIB=contrib
 endif
 SUBDIRS=include src bindings applications test scripts examples doc $(CONTRIB)
+SUBDIRS=include src bindings applications test scripts examples doc macosx_install_kit $(CONTRIB)
 EXTRA_DIST=build_rules.am nexus_spec.in nexus.spec autoversion.sh \
                 build_rpm.in README.cygwin README.WIN32 README.macosx \
+                README.MinGW make_mingw_links SConstruct nexus_scons_utils.py
+                README.MinGW make_mingw_links SConstruct nexus_scons_utils.py \
+                configure_mingw_kit
 # Add any flags here that you want passed to configure when you do
 # a "make distcheck"
 # DISTCHECK_CONFIGURE_FLAGS=--without-java
+MAINTAINERCLEANFILES = \
+ ChangeLog \
+ INSTALL \
+ aclocal.m4 \
+ config \
+ configure \
+ doc/tech_ref/NeXus_definitions.pdf \
+ doc/tech_ref/NeXus_definitions.txt \
+ include/nxconfig_h.in \
+ `find "$(srcdir)" -type f -name Makefile.in -print`

tags/4.2.1/examples

Property svn:mergeinfo set to
/trunk/examples merged eligible

tags/4.2.1/applications/NXtranslate/opengenie/Makefile.am

r1896	r1896
39	39	libnxgenie_la_LDFLAGS = -no-undefined -export-dynamic -module $(LDFLAGS)
40	40
41		EXTRA_DIST = README
	41	EXTRA_DIST = README nxgenie.gcl
42	42
43	43	include $(top_srcdir)/build_rules.am

tags/4.2.1/applications/NXtranslate/Makefile.am

r1896	r1896
68	68	nxtranslate_LDFLAGS = -static @HDF4_LDFLAGS@ @HDF5_LDFLAGS@ @XML_LDFLAGS@ $(LDFLAGS)
69	69
70		#EXTRA_DIST = CHANGES LICENSE README TODO
	70	EXTRA_DIST = $(srcdir)/.xml $(srcdir)/.nxt $(srcdir)/.dat $(srcdir)/.run
71	71
72	72	include $(top_srcdir)/build_rules.am

tags/4.2.1/applications/NXsummary/tclap/MultiArg.h

r1896	r1896
26	26	#include <string>
27	27	#include <vector>
	28	#include <cstdio>
28	29
29	30	#include <tclap/Arg.h>

tags/4.2.1/applications/NXsummary/tclap/ValueArg.h

r1896	r1896
26	26	#include <string>
27	27	#include <vector>
	28	#include <cstdio>
28	29
29	30	#include <tclap/Arg.h>

tags/4.2.1/applications/NXsummary/main.cpp

r1896	r1896
30	30	#include <string>
31	31	#include <cstring>
	32	#include <cstdio>
32	33	#include <vector>
33	34	#include "data_util.hpp"

tags/4.2.1/applications/nxdiff

                       r1896
 def getPercentDiff(left, right, nandiff=float("nan")):
+    diffs = 100. * numpy.fabs((left-right)/left)
+    # find the difference (absolute)
+    diffs = left-right
+    combine = numpy.fabs(left) + numpy.fabs(right)
+    # fix the denominator so there are not nans
+    try:
+        indices = (combine == 0)
+        left[indices] = 1.
+    except IndexError:
+        if combine == 0:
+            left = 1.
+    # do the percent part
+    diffs = 100. * numpy.fabs(diffs/left)
     try:
         diffs[0]

tags/4.2.1/applications/NXdir/string_util.cpp

                       r1896
  */
 static string float_to_str(double value){
   char temp[20];
   sprintf(temp,"%f",value);
+  char temp[40];
+  snprintf(temp,40,"%f",value);
   return string(temp);
 …
  */
 extern string int_to_str(const long value){
   char temp[20];
   sprintf(temp,"%d",value);
+  char temp[40];
+  snprintf(temp,40,"%d",value);
   return string(temp);

tags/4.2.1/applications/NXdir/data_writer.cpp

r1896	r1896
34	34
35	35	#define NXDATA "NXdata"
36		~~#define ATTR "ATTR"~~
37	36
38	37	using std::string;

tags/4.2.1/applications/NXbrowse.c

                       r1896
            USA
  For further information, see <http://www.neutron.anl.gov/NeXus/>
+ For further information, see <http://www.nexusformat.org>
  $Id$
 …
 #include <stdio.h>
 #include <string.h>
+#include <stdlib.h>
 #include "napi.h"
 #include "napiconfig.h"
+static char* my_readline(const char* prompt)
+{
+    char inputText[256];
+    char* stringPtr;
+    fprintf(stdout, "%s", prompt);
+    if (fgets(inputText, sizeof(inputText), stdin) == NULL)
+    {
+        return NULL;
+    }
+    if ((stringPtr = strchr(inputText, '\n')) != NULL)
+    {
+        *stringPtr = '\0';
+    }
+    return strdup(inputText);
+}
+#if HAVE_LIBREADLINE
+#include <readline/readline.h>
+#include <readline/history.h>
+#ifndef HAVE_RL_COMPLETION_MATCHES
+#define rl_completion_matches(a,b) completion_matches(a,b)
+#endif /* ifndef HAVE_RL_COMPLETION_MATCHES */
+#else
+#define rl_completion_matches(a,b) NULL
+#define rl_outstream stdout
+#define readline my_readline
+#endif
 #define StrEq(s1, s2) (strcmp((s1), (s2)) == 0)
 …
 static char nxFile[256];
+static NXhandle the_fileId;
+/*
+ * Freddie Akeroyd 18/10/2009
+ *
+ * Add in support for readline and completion (nxbrowse_complete) of commands
+ * (command_generator) and on data/group names (field_generator)
+ * a / character is appended to group names for display, but stripped off
+ * by the cd command (we may want to remove this and use openpath() later)
+ *
+ */
+typedef struct {
+    const char* name;
+    const char* doc;
+} COMMAND;
+COMMAND commands[] = {
+    { "cd", "Move into to a group" },
+    { "close", "Move out of a group" },
+    { "dir", "" },
+    { "read", "" },
+    { "open", "" },
+    { "help", "" },
+    { "info", "" },
+    { "exit", "" },
+    { "dump", "" },
+    { "bytesaschar", "" },
+    { NULL, NULL }
+};
+static char* command_generator(const char* text, int state)
+{
+    static int len, list_index;
+    const char* name;
+    if (!state)
+    {
+        list_index = 0;
+        len = strlen(text);
+    }
+    while( (name = commands[list_index].name) != NULL )
+    {
+        ++list_index;
+        if (strncasecmp(name, text, len) == 0)
+        {
+            return strdup(name);
+        }
+    }
+    return NULL;
+}
+struct name_item;
+struct name_item
+{
+    char* name;
+    struct name_item* next;
+};
+static char* field_generator(const char* text, int state)
+{
+    static int len;
+    struct name_item *item, *t_item;
+    static struct name_item *names = NULL, *last_item = NULL;
+    char* res;
+    int status, dataType;
+    NXname name, nxclass;
+    if (!state)
+    {
+        item = names;
+        while(item != NULL)
+        {
+            if (item->name != NULL)
+            {
+                free(item->name);
+                item->name = NULL;
+            }
+            t_item = item;
+            item = item->next;
+            t_item->next = NULL;
+            free(t_item);
+        }
+        last_item = names = NULL;
+        len = strlen(text);
+        if (NXinitgroupdir (the_fileId) != NX_OK)
+        {
+            return NULL;
+        }
+        do
+        {
+           status = NXgetnextentry (the_fileId, name, nxclass, &dataType);
+           if (status == NX_ERROR) break;
+           if (status == NX_OK)
+           {
+              if (strncmp(nxclass,"CDF",3) == 0){
+                  ;
+              }
+              else if (strncmp(name, text, len) == 0)
+              {
+                  item = (struct name_item*)malloc(sizeof(struct name_item));
+                  item->name = strdup(name);
+                  if (strcmp(nxclass,"SDS") != 0){
+                     strcat(item->name, "/");
+                  }
+                  item->next = NULL;
+                  if (last_item == NULL)
+                  {
+                    names = item;
+                  }
+                  else
+                  {
+                    last_item->next = item;
+                  }
+                  last_item = item;
+              }
+           }
+        } while (status == NX_OK);
+        last_item = names;
+    }
+    if (last_item != NULL)
+    {
+       res = strdup(last_item->name);
+       last_item = last_item->next;
+    }
+    else
+    {
+        res = NULL;
+    }
+    return res;
+}
+static char** nxbrowse_complete(const char* text, int start, int end)
+{
+    char** matches = NULL;
+    static char line[512];
+    strncpy(line, text+start, end-start);
+    line[end-start] = '\0';
+    if (start == 0)
+    {
+        matches = rl_completion_matches(text, command_generator);
+    }
+    else
+    {
+        matches = rl_completion_matches(text, field_generator);
+    }
+    return matches;
+}
 int main(int argc, char *argv[])
+{
+   NXhandle fileId;
+   char fileName[80], inputText[255], path[80], *command, *dimensions, *stringPtr;
+   char fileName[800], path[800], *command, *dimensions, *stringPtr;
+   char prompt[512];
+   char *inputText;
    NXname groupName, dataName;
    int status, groupLevel = 0, i;
+   printf ("NXBrowse %s Copyright (C) 2000 R. Osborn, M. Koennecke, P. Klosowski\n", NEXUS_VERSION);
+#if HAVE_LIBREADLINE
+   rl_readline_name = "NXbrowse";
+   rl_attempted_completion_function = nxbrowse_complete;
+#if READLINE_VERSION >= 0x500
+   rl_catch_signals = 0;
+#else
+#define rl_crlf() fprintf(rl_outstream, "\r\n");
+#define rl_on_new_line() 1
+#endif
+   using_history();
+#else
+#define rl_crlf()
+#define rl_on_new_line()
+#define add_history(a)
+#endif
+   printf ("NXBrowse %s Copyright (C) 2009 NeXus Data Format\n", NEXUS_VERSION);
 /* if there is a filename given on the command line use that,
 …
 /* Open input file and output global attributes */
    if (NXopen (fileName, NXACC_READ, &fileId) != NX_OK) {
+   if (NXopen (fileName, NXACC_READ, &the_fileId) != NX_OK) {
       printf ("NX_ERROR: Can't open %s\n", fileName);
       return NX_ERROR;
+   }
    PrintAttributes (fileId);
+   PrintAttributes (the_fileId);
    iByteAsChar = 0; /* Display remaining NX_INT8 and NX_UINT8 variables as integers by default */
 /* Input commands until the EXIT command is given */
    strcpy (path, "NX");
    do {
       printf ("%s> ", path);
       if (fgets(inputText, sizeof(inputText), stdin) == NULL)
+      sprintf (prompt, "%s> ", path);
+      if (getenv("NO_READLINE") != NULL)
+      {
+         return NX_OK;
+      }
+      if ((stringPtr = strchr(inputText, '\n')) != NULL)
+         *stringPtr = '\0';
+          inputText = my_readline(prompt);
+      }
+      else
+      {
+          inputText = readline(prompt);
+      }
+      if (inputText == NULL)
+      {
+          inputText = strdup("EXIT");
+      }
+      if (*inputText)
+      {
+          add_history(inputText);
+      }
       command = strtok(inputText," ");
       /* Check if a command has been given */
 …
       /* Command is to print a directory of the current group */
       if (StrEq(command, "DIR") || StrEq(command, "LS")) {
          status = NXBdir (fileId);
+         status = NXBdir (the_fileId);
+      }
       /* Command is to open the specified group */
       if (StrEq(command, "OPEN") || StrEq(command, "CD")) {
          stringPtr = strtok(NULL, " ");
+         stringPtr = strtok(NULL, " /");
          if (stringPtr != NULL) {
             strcpy (groupName, stringPtr);
+            status = NXBopen (fileId, groupName);
+            /* Add the group to the prompt string */
+            if (status == NX_OK) {
+               strcat (path, "/");
+               strcat (path, groupName);
+               groupLevel++;
+            }
+                         if (StrEq(groupName, "..")) {
+                                 strcpy(command, "CLOSE");
+                         } else {
+                                 status = NXBopen (the_fileId, groupName);
+                                 /* Add the group to the prompt string */
+                                 if (status == NX_OK) {
+                                         strcat (path, "/");
+                                         strcat (path, groupName);
+                                         groupLevel++;
+                                 }
+                         }
+         }
          else {
             printf ("NX_ERROR: Specify a group\n");
+            fprintf (rl_outstream, "NX_ERROR: Specify a group\n");
+         }
+      }
 …
             if (stringPtr != NULL) {
                strcpy (fileName, stringPtr);
                status = NXBdump (fileId, dataName, fileName);
+               status = NXBdump (the_fileId, dataName, fileName);
+            }
             else {
                printf ("NX_ERROR: Specify a dump file name \n");
+               fprintf (rl_outstream, "NX_ERROR: Specify a dump file name \n");
+            }
+         }
          else {
             printf ("NX_ERROR: Specify a data item\n");
+            fprintf (rl_outstream, "NX_ERROR: Specify a data item\n");
+         }
+      }
 …
             strcpy (dataName, stringPtr);
             dimensions = strtok(NULL, "[]");
             status = NXBread (fileId, dataName, dimensions);
+            status = NXBread (the_fileId, dataName, dimensions);
+         }
          else {
             printf ("NX_ERROR: Specify a data item\n");
+            fprintf (rl_outstream, "NX_ERROR: Specify a data item\n");
+         }
+      }
 …
       if (StrEq(command, "CLOSE")) {
          if (groupLevel > 0) {
             if (NXclosegroup (fileId) == NX_OK) {
+            if (NXclosegroup (the_fileId) == NX_OK) {
                /* Remove the group from the prompt string */
                stringPtr = strrchr (path, '/'); /* position of last group delimiter */
 …
+         }
          else {
             printf ("NX_WARNING: Already at root level of file\n");
+            fprintf (rl_outstream, "NX_WARNING: Already at root level of file\n");
+         }
+      }
 …
       /* Command is to exit the program */
       if (StrEq(command, "EXIT") || StrEq(command, "QUIT")) {
          for (i = groupLevel; i > 0; i--) NXclosegroup (fileId);
          NXclose (&fileId);
+         for (i = groupLevel; i > 0; i--) NXclosegroup (the_fileId);
+         NXclose (&the_fileId);
          return NX_OK;
+      }
       status = NX_OK;
+      free(inputText);
    } while (status == NX_OK);
    return NX_OK;

tags/4.2.1/scripts

Property svn:mergeinfo set to
/trunk/scripts merged eligible

tags/4.2.1/src/napi4.c

                       r1896
 ----------------------------------------------------------------------------*/
+#ifdef HDF4
 #include <stdlib.h>
 #include <assert.h>
 …
+  {
     int32 iNew, iRef, iTag;
     int iN, i, status;
+    int iN, i;
     int32 *pArray = NULL;
     NXname pText;
 …
+  {
     pNexusFile pFile;
-    ErrFunc oldErr;
     int datalen, type = NX_CHAR;
 …
       sRes->iTag = DFTAG_NDG;
       sRes->iRef = SDidtoref (pFile->iCurrentSDS);
+      oldErr = NXMGetError();
+      NXMSetError(NXpData, ignoreError);
+      NXMDisableErrorReporting();
       datalen = 1024;
       memset(&sRes->targetPath,0,1024);
 …
         NXIbuildPath(pFile,sRes->targetPath,1024);
+      }
       NXMSetError(NXpData,oldErr);
+      NXMEnableErrorReporting();
       return NX_OK;
+    }
 …
+  {
     pNexusFile pFile;
     int32 iVG, iRet, dataID, type = DFNT_CHAR8, length;
+    int32 dataID, type = DFNT_CHAR8, length;
     char name[] = "target";
 …
+  {
     pNexusFile pFile;
     int32 iVG, iRet, dataID, type = DFNT_CHAR8, length, dataType = NX_CHAR,
+    int32 dataID, type = DFNT_CHAR8, length, dataType = NX_CHAR,
       rank = 1, attType = NX_INT32;
     int iDim[1];
 …
     *iType = (int)iType32;
     iLen = iLen * DFKNTsize (*iType);
+    if(*iType == NX_CHAR){
+      iLen += 1;
+    }
     pData = (void *) malloc (iLen);
     if (!pData) {
 …
       fHandle->nxprintlink=NX4printlink;
+}
+#endif /*HDF4*/

tags/4.2.1/src/nxstack.c

                       r1896
   For further information, see <http://www.neutron.anl.gov/NeXus/>
+  Added code to support the path stack for NXgetpath,
+        Mark Koennecke, October 2009
 */
 #include <stdlib.h>
 …
   int fileStackPointer;
   fileStackEntry fileStack[MAXEXTERNALDEPTH];
+  int pathPointer;
+  char pathStack[NXMAXSTACK][NX_MAXNAMELEN];
 }fileStack;
 /*---------------------------------------------------------------------*/
 …
   memset(pNew,0,sizeof(fileStack));
   pNew->fileStackPointer = -1;
+  pNew->pathPointer = -1;
   return pNew;
+}
 …
     free(self);
+  }
+}
+/*---------------------------------------------------------------------*/
+int getFileStackSize(){
+  return sizeof(fileStack);
+}
 /*----------------------------------------------------------------------*/
 …
   return self->fileStackPointer;
+}
+/*----------------------------------------------------------------------*/
+void pushPath(pFileStack self, const char *name){
+  self->pathPointer++;
+  strncpy(self->pathStack[self->pathPointer],name,NX_MAXNAMELEN-1);
+}
+/*-----------------------------------------------------------------------*/
+void popPath(pFileStack self){
+  self->pathPointer--;
+  if(self->pathPointer < -1){
+    self->pathPointer = -1;
+  }
+}
+/*-----------------------------------------------------------------------*/
+int buildPath(pFileStack self, char *path, int pathlen){
+  int i, totalPathLength;
+  char *totalPath;
+  for(i = 0, totalPathLength = 5; i <= self->pathPointer; i++){
+    totalPathLength += strlen(self->pathStack[i]) + 1;
+  }
+  totalPath = malloc(totalPathLength*sizeof(char));
+  if(totalPath == NULL){
+    return 0;
+  }
+  memset(totalPath,0,totalPathLength*sizeof(char));
+  for(i = 0; i <= self->pathPointer; i++){
+    strcat(totalPath,"/");
+    strcat(totalPath,self->pathStack[i]);
+  }
+  strncpy(path,totalPath,pathlen-1);
+  free(totalPath);
+  return 1;
+}

tags/4.2.1/src/napi5.c

                       r1896
 ----------------------------------------------------------------------------*/
+#ifdef HDF5
 #include <stdlib.h>
 #include <assert.h>
 …
 static void buildCurrentPath(pNexusFile5 self, char *pathBuffer,
                              int pathBufferLen){
-  int length;
   memset(pathBuffer,0,pathBufferLen);
 …
   pNexusFile5 pFile;
   int chunk_size[H5S_MAX_RANK];
+  int i;
   pFile = NXI5assert (fid);
   memset(chunk_size,0,H5S_MAX_RANK*sizeof(int));
+  if (dimensions[0] == NX_UNLIMITED)
+     {
+     for (i = 0; i < H5S_MAX_RANK; i++)
+       {
+         chunk_size[i]= 1;
+       }
+     }
+  memcpy(chunk_size,dimensions,rank*sizeof(int));
+  if (dimensions[0] == NX_UNLIMITED){
+         chunk_size[0]= 1;
+  }
   return NX5compmakedata (fid, name, datatype, rank, dimensions, NX_COMP_NONE, chunk_size);
 …
+  {
     pNexusFile5 pFile;
-    ErrFunc oldErr;
     int datalen, type = NX_CHAR;
 …
       the path to the current node
     */
+    oldErr = NXMGetError();
+    NXMSetError(NXpData, ignoreError);
+    NXMDisableErrorReporting();
     datalen = 1024;
     memset(&sRes->targetPath,0,datalen*sizeof(char));
 …
       buildCurrentPath(pFile, sRes->targetPath, 1024);
+    }
     NXMSetError(NXpData,oldErr);
+    NXMEnableErrorReporting();
     sRes->linkType = 1;
     return NX_OK;
 …
     pNexusFile5 pFile;
     char linkTarget[1024];
     int type = NX_CHAR, length;
+    int type = NX_CHAR;
     int status;
 …
     pNexusFile5 pFile;
     char linkTarget[1024];
     int type = NX_CHAR, length;
+    int type = NX_CHAR;
     char *itemName = NULL;
     int status;
 …
   herr_t group_info1(hid_t loc_id, const char *name, void *opdata)
+  {
-    NexusFile5 self;
     H5G_stat_t statbuf;
     self.iNX = *((int*)opdata);
+    int iNX = *((int*)opdata);
     H5Gget_objinfo(loc_id, name, 0, &statbuf);
 …
+    {
       case H5G_GROUP:
         self.iNX++;
         *((int*)opdata)=self.iNX;
+        iNX++;
+        *((int*)opdata)=iNX;
         break;
       case H5G_DATASET:
         self.iNX++;
         *((int*)opdata)=self.iNX;
+        iNX++;
+        *((int*)opdata)=iNX;
         break;
       default:
 …
   /*-------------------------------------------------------------------------*/
   NXstatus  NX5getgroupinfo (NXhandle fid, int *iN, NXname pName, NXname pClass)
+  NXstatus  NX5getgroupinfo_recurse (NXhandle fid, int *iN, NXname pName, NXname pClass)
+  {
     pNexusFile5 pFile;
 …
     return NX_OK;
+  }
+/*------------------------------------------------------------------------*/
+static int hdf5ToNXType(int data_id, hid_t atype)
+/*---------------------------------------------------------------------------*/
+static int countObjectsInGroup(hid_t loc_id)
+{
+  int iPtype = -1;
+  hid_t sign_id, size_id;
+           if (data_id==H5T_STRING)
+           {
+             iPtype=NX_CHAR;
+           }
+           if (data_id==H5T_INTEGER)
+  int count = 0, type;
+  hsize_t numobj, i;
+  herr_t status;
+  status = H5Gget_num_objs(loc_id, &numobj);
+  if(status < 0) {
+    NXIReportError(NXpData,"Internal error, failed to retrive no of objects");
+    return 0;
+  }
+  for(i = 0; i < numobj; i++){
+    type = H5Gget_objtype_by_idx(loc_id,i);
+    if(type == H5G_GROUP || type == H5G_DATASET){
+      count++;
+    }
+  }
+  return count;
+}
+/*----------------------------------------------------------------------------*/
+  NXstatus  NX5getgroupinfo (NXhandle fid, int *iN, NXname pName, NXname pClass)
+  {
+    pNexusFile5 pFile;
+    hid_t atype, attr_id, gid;
+    char data[64];
+    int iRet;
+    pFile = NXI5assert (fid);
+    /* check if there is a group open */
+    if (pFile->iCurrentG == 0) {
+       strcpy (pName, "root");
+       strcpy (pClass, "NXroot");
+       gid = H5Gopen(pFile->iFID,"/");
+       *iN = countObjectsInGroup(gid);
+       H5Gclose(gid);
+    }
+    else {
+      strcpy (pName,pFile->name_ref);
+      attr_id = H5Aopen_name(pFile->iCurrentG,"NX_class");
+      if (attr_id<0) {
+         strcpy(pClass, NX_UNKNOWN_GROUP);
+      } else {
+        atype=H5Tcopy(H5T_C_S1);
+        H5Tset_size(atype,sizeof(data));
+        H5Aread(attr_id, atype, data);
+        strcpy(pClass,data);
+        pFile->iNX=0;
+        *iN = countObjectsInGroup(pFile->iCurrentG);
+        H5Aclose(attr_id);
+      }
+    }
+    return NX_OK;
+  }
+/*-------------------------------------------------------------------------
+ * Function: hdf5ToNXType
+ *
+ * Purpose:     Convert a HDF5 class to a NeXus "type";  it handles the following HDF5 classes
+ *  H5T_STRING
+ *  H5T_INTEGER
+ *  H5T_FLOAT
+ *
+ * Return: the NeXus "type"
+ *
+ *-------------------------------------------------------------------------
+ */
+  static int hdf5ToNXType(H5T_class_t tclass, hid_t atype)
+  {
+      int        iPtype = -1;
+      size_t     size_id;
+      H5T_sign_t sign_id;
+      if (tclass==H5T_STRING)
+      {
+          iPtype=NX_CHAR;
+      }
+      else if (tclass==H5T_INTEGER)
+      {
+          size_id=H5Tget_size(atype);
+          sign_id=H5Tget_sign(atype);
+          if (size_id==1)
+          {
+             size_id=H5Tget_size(atype);
+             sign_id=H5Tget_sign(atype);
+             if (size_id==1)
+             {
+                if (sign_id==H5T_SGN_2)
+                {
+                   iPtype=NX_INT8;
+                } else {
+                   iPtype=NX_UINT8;
+                }
+             }
+             else if (size_id==2)
+             {
+                if (sign_id==H5T_SGN_2)
+                {
+                   iPtype=NX_INT16;
+                } else {
+                   iPtype=NX_UINT16;
+                }
+             }
+             else if (size_id==4)
+             {
+                 if (sign_id==H5T_SGN_2)
+                 {
+                    iPtype=NX_INT32;
+                 } else {
+                    iPtype=NX_UINT32;
+                 }
+             }
+             else if(size_id == 8)
+             {
+                 if (sign_id==H5T_SGN_2)
+                 {
+                    iPtype=NX_INT64;
+                 } else {
+                    iPtype=NX_UINT64;
+                 }
+             }
+        } else if (data_id==H5T_FLOAT)
+            {
+            size_id=H5Tget_size(atype);
+            if (size_id==4)
+            {
+               iPtype=NX_FLOAT32;
+            }
+            else if (size_id==8)
+            {
+               iPtype=NX_FLOAT64;
+            }
+        }
+        if (iPtype == -1)
+        {
+         NXIReportError (NXpData, "ERROR: hdf5ToNXtype: invalid type");
+        }
+           return iPtype;
+}
+              if (sign_id==H5T_SGN_2)
+              {
+                  iPtype=NX_INT8;
+              } else {
+                  iPtype=NX_UINT8;
+              }
+          }
+          else if (size_id==2)
+          {
+              if (sign_id==H5T_SGN_2)
+              {
+                  iPtype=NX_INT16;
+              } else {
+                  iPtype=NX_UINT16;
+              }
+          }
+          else if (size_id==4)
+          {
+              if (sign_id==H5T_SGN_2)
+              {
+                  iPtype=NX_INT32;
+              } else {
+                  iPtype=NX_UINT32;
+              }
+          }
+          else if(size_id == 8)
+          {
+              if (sign_id==H5T_SGN_2)
+              {
+                  iPtype=NX_INT64;
+              } else {
+                  iPtype=NX_UINT64;
+              }
+          }
+      }
+      else if (tclass==H5T_FLOAT)
+      {
+          size_id=H5Tget_size(atype);
+          if (size_id==4)
+          {
+              iPtype=NX_FLOAT32;
+          }
+          else if (size_id==8)
+          {
+              iPtype=NX_FLOAT64;
+          }
+      }
+      if (iPtype == -1)
+      {
+          NXIReportError (NXpData, "ERROR: hdf5ToNXtype: invalid type");
+      }
+      return iPtype;
+  }
 /*--------------------------------------------------------------------------*/
+static int h5MemType(hid_t atype)
+{
+  hid_t data_id, size_id, sign_id, memtype_id = -1;
+  data_id = H5Tget_class(atype);
+       if (data_id==H5T_INTEGER)
+     {
+        size_id=H5Tget_size(atype);
+        sign_id=H5Tget_sign(atype);
+        if (size_id==1)
+        {
+            if (sign_id==H5T_SGN_2)
+            {
+               memtype_id = H5T_NATIVE_INT8;
+            } else {
+               memtype_id = H5T_NATIVE_UINT8;
+            }
+        }
+        else if (size_id==2)
+        {
+           if (sign_id==H5T_SGN_2)
+           {
+              memtype_id = H5T_NATIVE_INT16;
+           } else {
+              memtype_id = H5T_NATIVE_UINT16;
+           }
+        }
+        else if (size_id==4)
+        {
+          if (sign_id==H5T_SGN_2)
+          {
+             memtype_id = H5T_NATIVE_INT32;
+          } else {
+             memtype_id = H5T_NATIVE_UINT32;
+          }
+        }
+        else if (size_id==8)
+        {
+          if (sign_id==H5T_SGN_2)
+          {
+            memtype_id = H5T_NATIVE_INT64;
+          } else {
+            memtype_id = H5T_NATIVE_UINT64;
+          }
+        }
+  static int h5MemType(hid_t atype)
+  {
+      hid_t memtype_id = -1;
+      size_t size_id;
+      H5T_sign_t sign_id;
+      H5T_class_t data_id;
+      data_id = H5Tget_class(atype);
+      if (data_id==H5T_INTEGER)
+      {
+          size_id=H5Tget_size(atype);
+          sign_id=H5Tget_sign(atype);
+          if (size_id==1)
+          {
+              if (sign_id==H5T_SGN_2)
+              {
+                  memtype_id = H5T_NATIVE_INT8;
+              } else {
+                  memtype_id = H5T_NATIVE_UINT8;
+              }
+          }
+          else if (size_id==2)
+          {
+              if (sign_id==H5T_SGN_2)
+              {
+                  memtype_id = H5T_NATIVE_INT16;
+              } else {
+                  memtype_id = H5T_NATIVE_UINT16;
+              }
+          }
+          else if (size_id==4)
+          {
+              if (sign_id==H5T_SGN_2)
+              {
+                  memtype_id = H5T_NATIVE_INT32;
+              } else {
+                  memtype_id = H5T_NATIVE_UINT32;
+              }
+          }
+          else if (size_id==8)
+          {
+              if (sign_id==H5T_SGN_2)
+              {
+                  memtype_id = H5T_NATIVE_INT64;
+              } else {
+                  memtype_id = H5T_NATIVE_UINT64;
+              }
+          }
       } else if (data_id==H5T_FLOAT)
+        {
           size_id=H5Tget_size(atype);
           if (size_id==4)
+          {
              memtype_id = H5T_NATIVE_FLOAT;
           } else if (size_id==8) {
              memtype_id = H5T_NATIVE_DOUBLE;
+          }
+      {
+          size_id=H5Tget_size(atype);
+          if (size_id==4)
+          {
+              memtype_id = H5T_NATIVE_FLOAT;
+          } else if (size_id==8) {
+              memtype_id = H5T_NATIVE_DOUBLE;
+          }
+      }
       if (memtype_id == -1)
+      {
          NXIReportError (NXpData, "ERROR: h5MemType: invalid type");
+          NXIReportError (NXpData, "ERROR: h5MemType: invalid type");
+      }
       return memtype_id;
+}
+  }
   /*-------------------------------------------------------------------------*/
 …
     hid_t grp, attr1,type,atype;
     int iRet,iPtype, i;
+    int idx,data_id,size_id, sign_id;
+    int idx;
+    H5T_class_t data_id;
     char data[128];
     char ph_name[1024];
 …
      pNexusFile5 pFile;
      int iStart[H5S_MAX_RANK], status;
+     hid_t data_id, memtype_id, size_id, sign_id;
+     hid_t memtype_id;
+     H5T_class_t data_id;
      int dims;
 …
      int i, iRank, mType, iRet;
      hsize_t myDim[H5S_MAX_RANK];
      hid_t data_id,size_id,sign_id;
+     H5T_class_t data_id;
      pFile = NXI5assert (fid);
 …
      hsize_t mySize[H5S_MAX_RANK];
      hsize_t mStart[H5S_MAX_RANK];
+     hid_t   memspace, iRet, data_id;
+     hid_t   memtype_id, size_id, sign_id;
+     hid_t   memspace, iRet;
+     H5T_class_t data_id;
+     hid_t   memtype_id;
      char *tmp_data = NULL;
      char *data1;
 …
+        }
        /* map datatypes of other plateforms */
        if (data_id==H5T_STRING)
+       if (data_id == H5T_STRING)
+       {
          dims = H5Tget_size(pFile->iCurrentT);
 …
                      pFile->iCurrentS, H5P_DEFAULT,data);
+      }
+      /* cleanup */
+      if (data_id == H5T_STRING) { /* we used H5Tcopy */
+         H5Tclose(memtype_id);
+      }
+      H5Sclose(memspace);
       if (iRet < 0)
+        {
           NXIReportError (NXpData, "ERROR: Reading slab failed");
 …
+   {
      pNexusFile5 pFile;
      hid_t attr_id,size_id,sign_id;
+     hid_t attr_id;
      hid_t iRet, atype, aspace;
      int iPType,rank;
 …
      unsigned int idx;
      int vid;
+     herr_t iRet;
      pFile = NXI5assert (fid);
      idx=0;
 …
+  {
     pNexusFile5 pFile;
+    int u, datalen, type = NX_CHAR;
+    char group_name[64], class_name[64];
+    ErrFunc oldErr;
+    int datalen, type = NX_CHAR;
     pFile = NXI5assert (fileid);
 …
         the path to the current node
       */
+      oldErr = NXMGetError();
+      NXMSetError(NXpData, ignoreError);
+      NXMDisableErrorReporting();
       datalen = 1024;
       memset(sRes->targetPath,0,datalen*sizeof(char));
 …
         buildCurrentPath(pFile,sRes->targetPath,1024);
+      }
       NXMSetError(NXpData,oldErr);
+      NXMEnableErrorReporting();
       sRes->linkType = 0;
       return NX_OK;
 …
       fHandle->nxprintlink=NX5printlink;
+}
+#endif /* HDF5 */

tags/4.2.1/src/nxio.c

                       r1896
  *  For further information, see <http://www.neutron.anl.gov/NeXus/>
  */
+#include <mxml.h>
+#ifdef NXXML
+#include <mxml.h>
 #include <assert.h>
 #include "napi.h"
 …
   const char *typeString;
   mxml_node_t* tnode;
+  mxml_type_t myType;
+  int i, nx_type = -1;
+  int nx_type = -1;
   int table_mode = 0;
 …
 mxml_type_t nexusTypeCallback(mxml_node_t *parent){
   const char *typeString;
-  mxml_node_t * tnode;
   if(strstr(parent->value.element.name,"?xml") != NULL ||
 …
   long address, maxAddress;
   pNXDS dataset = NULL;
   int i, table_mode;
+  int table_mode;
   parent = node->parent;
 …
 static void stringIntoBuffer(char **buffer, char **bufPtr, int *bufSize,
                       char *string){
   int i;
+  size_t i;
   for(i = 0; i < strlen(string); i++){
 …
+}
 #endif
+#endif /*NXXML*/

tags/4.2.1/src/nxstack.h

                       r1896
   For further information, see <http://www.neutron.anl.gov/NeXus/>
+  Added functions to deal with the path stack for NXgetpath
+  Mark Koennecke, October 2009
 */
 #ifndef NEXUSFILESTACK
 …
 pFileStack makeFileStack();
 void killFileStack(pFileStack self);
+int getFileStackSize();
 void pushFileStack(pFileStack self, pNexusFunction pDriv, char *filename);
 …
 int fileStackDepth(pFileStack self);
+void pushPath(pFileStack self, const char *name);
+void popPath(pFileStack self);
+int buildPath(pFileStack self, char *path, int pathlen);
 #endif

tags/4.2.1/src/napi.c

                       r1896
   static void NXNXNXReportError(void *pData, char *string)
+  {
     printf("%s \n",string);
+    fprintf(stderr, "%s \n", string);
+  }
   /*---------------------------------------------------------------------*/
   void *NXpData = NULL;
+  void (*NXIReportError)(void *pData, char *string) = NXNXNXReportError;
+  void *NXEHpData = NULL;
+  void (*NXEHIReportError)(void *pData, char *string) = NXNXNXReportError;
+#ifdef HAVE_TLS
+  __thread void *NXEHpTData = NULL;
+  __thread void (*NXEHIReportTError)(void *pData, char *string) = NULL;
+#endif
+  void NXIReportError(void *pData, char *string) {
+#ifdef HAVE_TLS
+        if (NXEHIReportTError) {
+                (*NXEHIReportTError)(NXEHpTData, string);
+                return;
+        }
+#endif
+        (*NXEHIReportError)(NXEHpData, string);
+  }
   /*---------------------------------------------------------------------*/
+  extern void NXMSetError(void *pData,
+                              void (*NewError)(void *pD, char *text))
+  {
+    NXpData = pData;
+    NXIReportError = NewError;
+  extern void NXMSetError(void *pData, void (*NewError)(void *pD, char *text))
+  {
+    NXEHpData = pData;
+    NXEHIReportError = NewError;
+  }
+/*----------------------------------------------------------------------*/
+  extern void NXMSetTError(void *pData, void (*NewError)(void *pD, char *text))
+  {
+#ifdef HAVE_TLS
+    NXEHpTData = pData;
+    NXEHIReportTError = NewError;
+#else
+    NXMSetError(pData, NewError);
+#endif
+  }
 /*----------------------------------------------------------------------*/
 extern ErrFunc NXMGetError(){
+  return NXIReportError;
+#ifdef HAVE_TLS
+        if (NXEHIReportTError) {
+                return NXEHIReportTError;
+        }
+#endif
+  return NXEHIReportError;
+}
 …
 /*----------------------------------------------------------------------*/
+static ErrFunc last_errfunc = NXNXNXReportError;
+ErrFunc last_global_errfunc = NXNXNXReportError;
+#ifdef HAVE_TLS
+__thread ErrFunc last_thread_errfunc = NULL;
+#endif
 extern void NXMDisableErrorReporting()
+{
+    last_errfunc = NXMGetError();
+    NXMSetError(NXpData, NXNXNoReport);
+#ifdef HAVE_TLS
+        if (NXEHIReportTError) {
+                last_thread_errfunc = NXEHIReportTError;
+                NXEHIReportTError = NXNXNoReport;
+                return;
+        }
+        last_thread_errfunc = NULL;
+#endif
+        last_global_errfunc = NXEHIReportError;
+        NXEHIReportError = NXNXNoReport;
+}
 extern void NXMEnableErrorReporting()
+{
+    NXMSetError(NXpData, last_errfunc);
+#ifdef HAVE_TLS
+        if (last_thread_errfunc) {
+                NXEHIReportTError = last_thread_errfunc;
+                last_thread_errfunc = NULL;
+                return;
+        }
+#endif
+        NXEHIReportError = last_global_errfunc;
+}
 …
+{
   FILE *fd = NULL;
+  int iRet, fapl;
+  NXhandle handle;
+  int iRet;
   /*
 …
   int status;
   pFileStack fileStack = NULL;
-  NXhandle hfile;
   *gHandle = NULL;
 …
     pFileStack fileStack;
     char nxurl[1024], exfile[512], expath[512];
-    ErrFunc oldError;
     pNexusFunction pFunc = NULL;
 …
     status = pFunc->nxopengroup(pFunc->pNexusData, name, nxclass);
+    oldError = NXMGetError();
+    NXIReportError = NXNXNoReport;
+    if(status == NX_OK){
+      pushPath(fileStack,name);
+    }
+    NXMDisableErrorReporting();
     attStatus = NXgetattr(fid,"napimount",nxurl,&length, &type);
     NXIReportError = oldError;
+    NXMEnableErrorReporting();
     if(attStatus == NX_OK){
       /*
 …
     fileStack = (pFileStack)fid;
     if(fileStackDepth(fileStack) == 0){
+      return pFunc->nxclosegroup(pFunc->pNexusData);
+      status = pFunc->nxclosegroup(pFunc->pNexusData);
+      if(status == NX_OK){
+        popPath(fileStack);
+      }
+      return status;
     } else {
       /* we have to check for leaving an external file */
 …
       } else {
         status = pFunc->nxclosegroup(pFunc->pNexusData);
+        if(status == NX_OK){
+          popPath(fileStack);
+        }
+      }
       return status;
 …
   NXstatus  NXopendata (NXhandle fid, CONSTCHAR *name)
+  {
+    int status;
+    pFileStack fileStack = NULL;
     pNexusFunction pFunc = handleToNexusFunc(fid);
+    return pFunc->nxopendata(pFunc->pNexusData, name);
+    fileStack = (pFileStack)fid;
+    status = pFunc->nxopendata(pFunc->pNexusData, name);
+    if(status == NX_OK){
+      pushPath(fileStack,name);
+    }
+    return status;
+  }
 …
   NXstatus  NXclosedata (NXhandle fid)
+  {
+    pNexusFunction pFunc = handleToNexusFunc(fid);
+    return pFunc->nxclosedata(pFunc->pNexusData);
+    int status;
+    pFileStack fileStack = NULL;
+    pNexusFunction pFunc = handleToNexusFunc(fid);
+    fileStack = (pFileStack)fid;
+    status = pFunc->nxclosedata(pFunc->pNexusData);
+    if(status == NX_OK){
+      popPath(fileStack);
+    }
+    return status;
+  }
 …
     return status;
+  }
+  oldError = NXMGetError();
+  NXIReportError = NXNXNoReport;
+  NXMDisableErrorReporting();
   attStatus = NXgetattr(fid,"napimount",nxurl,&length, &type);
   NXIReportError = oldError;
+  NXMEnableErrorReporting();
   pFunc->nxclosegroup(pFunc->pNexusData);
   if(attStatus == NX_OK){
 …
+}
 /*------------------------------------------------------------------------
   Implementation of NXopenpath.
+  Implementation of NXopenpath
   --------------------------------------------------------------------------*/
 static int isDataSetOpen(NXhandle hfil)
 …
+{
   int status;
-  NXname pathElem;
   char *pPtr;
 …
 static NXstatus stepOneUp(NXhandle hfil, char *name)
+{
   int status, datatype;
+  int datatype;
   NXname name2, xclass;
   char pBueffel[256];
 …
 static NXstatus stepOneGroupUp(NXhandle hfil, char *name)
+{
   int status, datatype;
+  int datatype;
   NXname name2, xclass;
   char pBueffel[256];
 …
   return NX_OK;
+}
+/*---------------------------------------------------------------------*/
 NXstatus NXIprintlink(NXhandle fid, NXlink* link)
+{
      pNexusFunction pFunc = handleToNexusFunc(fid);
      return pFunc->nxprintlink(pFunc->pNexusData, link);
+}
+/*----------------------------------------------------------------------*/
+NXstatus NXgetpath(NXhandle fid, char *path, int pathlen){
+  int status;
+  pFileStack fileStack = NULL;
+  fileStack = (pFileStack)fid;
+  status = buildPath(fileStack,path,pathlen);
+  if(status != 1){
+    return NX_ERROR;
+  }
+  return NX_OK;
+}
 …
   ---------------------------------------------------------------------*/
 char *NXIformatNeXusTime(){
-    char *timeData;
     time_t timer;
     char* time_buffer = NULL;
 …
    */
   NXstatus  NXfopen(char * filename, NXaccess* am,
                                  NexusFunction* pHandle)
+                                 NXhandle pHandle)
+  {
         NXstatus ret;
 …
         if (ret == NX_OK)
+        {
             memcpy(pHandle, fileid, sizeof(NexusFunction));
+          memcpy(pHandle, fileid, getFileStackSize());
+        }
         else
+        {
             memset(pHandle, 0, sizeof(NexusFunction));
+          memset(pHandle, 0, getFileStackSize());
+        }
         if (fileid != NULL)
 …
  * a temporary copy as NXclose will try to free() this
  */
   NXstatus  NXfclose (NexusFunction* pHandle)
+  NXstatus  NXfclose (NXhandle pHandle)
+  {
     NXhandle h;
     NXstatus ret;
     h = (NXhandle)malloc(sizeof(NexusFunction));
     memcpy(h, pHandle, sizeof(NexusFunction));
+    h = (NXhandle)malloc(getFileStackSize());
+    memcpy(h, pHandle, getFileStackSize());
     ret = NXclose(&h);          /* does free(h) */
     memset(pHandle, 0, sizeof(NexusFunction));
+    memset(pHandle, 0, getFileStackSize());
     return ret;
+  }
 /*---------------------------------------------------------------------*/
   NXstatus  NXfflush(NexusFunction* pHandle)
+  NXstatus  NXfflush(NXhandle pHandle)
+  {
     NXhandle h;
     NXstatus ret;
     h = (NXhandle)malloc(sizeof(NexusFunction));
     memcpy(h, pHandle, sizeof(NexusFunction));
+    h = (NXhandle)malloc(getFileStackSize());
+    memcpy(h, pHandle, getFileStackSize());
     ret = NXflush(&h);          /* modifies and reallocates h */
     memcpy(pHandle, h, sizeof(NexusFunction));
+    memcpy(pHandle, h, getFileStackSize());
     return ret;
+  }
 …
+  }
+/*-----------------------------------------------------------------------*/
   NXstatus  NXfcompmakedata(NXhandle fid, char *name,
                 int *pDatatype,
 …
+  }
+/*--------------------------------------------------------------------------*/
+NXstatus NXfgetpath(NXhandle fid, char *path, int *pathlen)
+{
+  return NXgetpath(fid,path,*pathlen);
+}
+const char* NXgetversion()
+{
+    return NEXUS_VERSION ;
+}

tags/4.2.1/src/Makefile.am

                       r1896
 AM_CPPFLAGS=-I$(top_srcdir)/include @HDF4_CPPFLAGS@ @HDF5_CPPFLAGS@ @XML_CPPFLAGS@ -DIN_NEXUS_LIBRARY
+AM_LDFLAGS=-version-info $(NXLTVERSINFO)
 AM_CFLAGS=-prefer-pic
 …
 #SUBDIRS=nxdict
 libNeXus_la_SOURCES = napi.c napiu.c nxstack.c nxstack.h stptok.c nxdataset.c nxdataset.h nx_stptok.h $(H4SRC) $(H5SRC) $(XMLSRC) $(MINGW_SRC)
+libNeXus_la_SOURCES = napi.c napiu.c nxstack.c nxstack.h stptok.c  nxdataset.c nxdataset.h nx_stptok.h $(H4SRC) $(H5SRC) $(XMLSRC) $(MINGW_SRC)
 libNeXus_la_LDFLAGS = -export-symbols nexus_symbols.sym @SHARED_LDFLAGS@ @HDF4_LDFLAGS@ @HDF5_LDFLAGS@ @XML_LDFLAGS@ $(LDFLAGS)
 libNeXus_la_DEPENDENCIES = nexus_symbols.sym

tags/4.2.1/src/nxdataset.c

                       r1896
 double getNXDatasetValue(pNXDS dataset, int pos[]){
   int address;
+  double value;
   if(dataset == NULL){
     return 0;
 …
 char  *getNXDatasetText(pNXDS dataset){
   char *resultBuffer = NULL;
   int length, status = 1;
+  int status = 1;
   if(dataset == NULL){

tags/4.2.1/src/nxxml.c

                       r1896
  *  For further information, see <http://www.nexusformat.org>
  */
+#ifdef NXXML
 #include <stdio.h>
 #include <napi.h>
 …
 #define XMLSTACK_OPTION_TABLE           0x1 /**< indicates table option in xmlStack */
-/**
- * Freddie Akeroyd 14/7/2008
- * Add NeXus schema support - this uses BASE.xsd as the initial file
- */
-#define NEXUS_SCHEMA_VERSION    "3.0"   /**< version of NeXus definition schema */
-#define NEXUS_SCHEMA_NAMESPACE  "http://definition.nexusformat.org/schema/" NEXUS_SCHEMA_VERSION        /**< XML schema namespace specified by xmlns */
-#define NEXUS_SCHEMA_FILE       NEXUS_SCHEMA_NAMESPACE "/BASE.xsd" /**< location of default schema file for namespace */
 /*---------------------------------------------------------------------*/
 …
     mxmlElementSetAttr(current,"xmlns:xsi","http://www.w3.org/2001/XMLSchema-instance");
     mxmlElementSetAttr(current,"xsi:schemaLocation",
         NEXUS_SCHEMA_NAMESPACE " " NEXUS_SCHEMA_FILE);
+        NEXUS_SCHEMA_NAMESPACE " " NEXUS_SCHEMA_URL);
     time_buffer = NXIformatNeXusTime();
     if(time_buffer != NULL){
 …
   pXMLNexus xmlHandle = NULL;
   mxml_node_t *newGroup = NULL;
-  char error[1024];
   xmlHandle = (pXMLNexus)fid;
 …
   getNumberText(datatype,typestring,130);
   if(rank > 1 || dimensions[0] > 1) {
+  if(rank > 1 || datatype == NX_CHAR || dimensions[0] > 1) {
     strcat(typestring,"[");
     snprintf(pNumber,19,"%d",dimensions[0]);
 …
   const char* name;
   pNXDS dataset;
   int i, offset, length, type, rank, dim[NX_MAXRANK];
+  int i, offset, length;
   char *pPtr = NULL;
   xmlHandle = (pXMLNexus)fid;
 …
   const char* name;
   pNXDS dataset;
   int i, offset, length, type, rank, dim[NX_MAXRANK];
+  int i, offset, length;
   xmlHandle = (pXMLNexus)fid;
   assert(xmlHandle);
 …
   char error[1024];
   const char *attData = NULL;
+  int iValue, nx_type;
+  float fValue;
+  int nx_type;
   xmlHandle = (pXMLNexus)fid;
 …
   pXMLNexus xmlHandle = NULL;
   mxml_node_t *current = NULL;
   int stackPtr, currentAtt, skip;
+  int stackPtr, skip;
   xmlHandle = (pXMLNexus)fid;
 …
   mxml_node_t *current = NULL;
   char *pathString = NULL, *result = NULL;
-  int count;
   path = (mxml_node_t **)malloc(NXMAXSTACK*sizeof(mxml_node_t *));
   if(path == NULL){
     NXIReportError(NXpData,"ERROR: out of memory follwoing link path");
+    NXIReportError(NXpData,"ERROR: out of memory following link path");
     return NULL;
+  }
 …
 /*--------------------------------------------------------------------*/
 int  NXXcompress(NXhandle fid, int comp){
+  NXIReportError(NXpData,"NXcompress is deprecated, IGNORED");
+  /* that will throw an exception in the Java API, errors have to be fatal */
+  /* NXIReportError(NXpData,"NXcompress is deprecated, IGNORED"); */
   return NX_OK;
+}
 …
+}
+#endif /*NXXML*/

tags/4.2.1/src/nexus_symbols.txt

                       r1896
 nxifputattr_
 nxifree_
+nxifgetpath_
 nxigetattr_
 nxigetattrinfo_
 …
 nxiopengrouppath_
 nxiopenpath_
+nxigetpath_
 nxiopensourcegroup_
 nxiputattr_
 …
 nxiisexternalgroup_
 NXMSetError
+NXMSetTError
 NXIReportError
 NXIprintlink

tags/4.2.1/bindings

Property svn:mergeinfo set to
/trunk/bindings merged eligible

tags/4.2.1/bindings/idl/NeXusIDL-API.dlm

r1896	r1896
8	8	FUNCTION NXOPENPATH 0 IDL_MAXPARAMS
9	9	FUNCTION NXOPENGROUPPATH 0 IDL_MAXPARAMS
	10	FUNCTION NXGETPATH 0 IDL_MAXPARAMS
10	11	FUNCTION NXMAKEGROUP 0 IDL_MAXPARAMS
11	12	FUNCTION NXCLOSEGROUP 0 IDL_MAXPARAMS

tags/4.2.1/bindings/idl/NeXusIDL-API.c

                       r1896
   return IDL_GettmpInt(status);
+}
+/*======================================================================
+ * NXgetpath
+ * string = NXgetpath(file_id)
+ *======================================================================*/
+static IDL_VPTR NXgetpath_this(int argc, IDL_VPTR *argv)
+{
+  int fileid;
+  NXhandle hHandle;
+  int iHandle, status;
+  char path[1024];
+  if (argc != 1) {
+        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "One argument expected");
+        return IDL_StrToSTRING("One argument expected");
+        }
+  IDL_ENSURE_SCALAR(argv[0]);
+  fileid = (int)IDL_LongScalar(argv[0]);
+  if(HHCheckIfHandleExists(fileid) == -1) {
+        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
+        return IDL_StrToSTRING("ERROR: Unknown file ID");
+        }
+  hHandle = HHGetPointer(fileid);
+  NXMSetError(NULL,idlError);
+  status = NXgetpath(hHandle,path,1024);
+  if(status == NX_ERROR){
+        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
+        return IDL_StrToSTRING(nexusError);
+  }
+   return IDL_StrToSTRING(path);
+}
 …
     { NXsetnumberformat_this, "NXSETNUMBERFORMAT", 0, IDL_MAXPARAMS, 0, 0},
     { NXopenpath_this, "NXOPENPATH", 0, IDL_MAXPARAMS, 0, 0},
+        { NXopengrouppath_this, "NXOPENGROUPPATH", 0, IDL_MAXPARAMS, 0, 0},
+    { NXopengrouppath_this, "NXOPENGROUPPATH", 0, IDL_MAXPARAMS, 0, 0},
+    { NXgetpath_this, "NXGETPATH", 0, IDL_MAXPARAMS, 0, 0},
     { NXmakegroup_this, "NXMAKEGROUP", 0, IDL_MAXPARAMS, 0, 0},
     { NXopengroup_this, "NXOPENGROUP", 0, IDL_MAXPARAMS, 0, 0},

tags/4.2.1/bindings/swig/nxinterhelper.h

r1896	r1896
23	23	int nx_opengrouppath(void handle, char path);
24	24	int nx_openpath(void handle, char path);
	25	extern char nx_getpath(void handle);
25	26	int nx_closegroup(void *handle);
26	27	char nx_getnextentry(void handle, char separator);

tags/4.2.1/bindings/swig/nxinter.i

r1896	r1896
57	57	extern int nx_openpath(void handle, char path);
58	58	extern int nx_opengrouppath(void handle, char path);
	59	extern char nx_getpath(void handle);
59	60	extern int nx_closegroup(void *handle);
60	61	extern char nx_getnextentry(void handle, char separator);

tags/4.2.1/bindings/swig/nxinterhelper.c

                       r1896
+}
 /*--------------------------------------------------------------------*/
+char *nx_getpath(void *handle){
+  int status;
+  NXhandle hfil;
+  char path[1024];
+  hfil = (NXhandle)handle;
+  status = NXgetpath(hfil,path,1024);
+  if(status == NX_OK){
+    return strdup(path);
+  } else {
+    return strdup("Error in NXgetpath");
+  }
+}
+/*--------------------------------------------------------------------*/
 int nx_closegroup(void *handle){
   int status;

tags/4.2.1/bindings/f90/Makefile.am

r1896	r1896
29	29	#====================================================================
30	30	lib_LTLIBRARIES = libNeXus90.la
	31	AM_LDFLAGS=-version-info $(NXLTVERSINFO)
31	32
32	33	libNeXus90_la_SOURCES = NXmodule.f90 NXUmodule.f90

tags/4.2.1/bindings/java/Makefile.am

r1896	r1896
58	58	# jni definitions
59	59	lib_LTLIBRARIES = libjnexus.la
	60	AM_LDFLAGS=-version-info $(NXLTVERSINFO)
60	61	libjnexus_la_SOURCES = native/hdfnativeImp.c \
61	62	native/hdfexceptionImp.c \

tags/4.2.1/bindings/java/native/NexusFile.c

                       r1896
    Updated for 64 bit types, Mark Koennecke, August 2007
+   Added NXinitattrdir and NXinitgroupdir, Mark Koennecke, October 2009
+   Added NXgetpath, Mark Koennecke, October 2009
    IMPLEMENTATION NOTES
 …
    the integer first before it can do useful work.
 */
 #include <stdlib.h>
 …
 #endif
+//#define DEBUG
+#ifdef DEBUG
+static FILE *fd = NULL;
+#endif
+/* #define DEBUG */
+static JavaVM *jvm;  // Global variable
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
+    JNIEnv *env;
+    jclass nexusException;
+    jint ret = (*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_1);
+    assert(ret == JNI_OK);
+    jvm = vm;
+    nexusException = (*env)->FindClass(env,"org/nexusformat/NexusException");
+    if (nexusException == NULL) {
+        fprintf(stderr, "cannot find NexusException - this will not work. Terminating.");
+        assert(nexusException);
+    }
+    return JNI_VERSION_1_1;
+}
 /*---------------------------------------------------------------------------
                               ERROR TREATMENT
+  The NAPI writes any errors to stdout through a special function.
+  This is not very feasible in a Java environment where an exception should
+  be thrown. Fortunately it is possible to define an own error processing
+  function to be used for error processing. This error handling function
+  is defined here. A NexusException is constructed and thrown.
+  The NAPI posts any errors to a customisable function.
+  We construct and throw a NexusException with the message received.
   --------------------------------------------------------------------------*/
+static void JapiError(void *pData, char *text)
+{
+    JNIEnv *env = (JNIEnv *)pData;
+    jclass jc;
+    jmethodID jm;
+    jobject exception;
+    jstring jtext;
+    char *args[2];
+    assert(env);
+static void JapiError(void *pData, char *text) {
+    JNIEnv *env = pData;
+    jclass nexusException;
 #ifdef DEBUG
+    fprintf(fd,"JapiError called with: %s\n", text);
+#endif
+    jc = (*env)->FindClass(env,"org/nexusformat/NexusException");
+    assert(jc);
+    jm = (*env)->GetMethodID(env, jc, "<init>","(Ljava/lang/String;)V");
+    assert(jm != NULL);
+    jtext = (*env)->NewStringUTF(env,text);
+    args[0] = (char *)jtext;
+    args[1] = 0;
+    exception = (*env)->NewObjectA(env, jc, jm, (jvalue *) args);
+    (*env)->Throw(env, exception);
+    fprintf(stderr,"JapiError called with: %s\n", text);
+#endif
+    /* ignore env passed in seems safer */
+    (*jvm)->AttachCurrentThread (jvm, (void **) &env, NULL);
+    if (env == NULL) {
+        // if there is no thread environment we do not need to throw an exception
+        return;
+    }
+    // Find and store the NexusException class for use in JapiError
+    nexusException = (*env)->FindClass(env,"org/nexusformat/NexusException");
+    (*env)->ThrowNew(env, nexusException, text);
+}
 …
     int iRet;
+#ifdef DEBUG
+    if(fd == NULL)
+    {
+        fd = fopen("jnexusdebug.dat","w");
+    }
+#endif
+    /* set error handler */
+    NXMSetError(env,JapiError);
+    /* set error handler */
+    NXMSetTError(env,JapiError);
     /* extract the filename as a C char* */
     fileName = (char *) (*env)->GetStringUTFChars(env,filename,0);
+    fileName = (char *) (*env)->GetStringUTFChars(env, filename, 0);
     /* call NXopen */
 #ifdef DEBUG
     fprintf(fd,"Calling NXopen on %s, with %d\n", fileName,access);
+    fprintf(stderr,"Calling NXopen on %s, with %d\n", fileName, access);
 #endif
     iRet = NXopen(fileName,access,&handle);
 #ifdef DEBUG
     fprintf(fd,"Handle %d allocated for %s\n", handle, fileName);
+    fprintf(stderr,"Handle allocated for %s\n", fileName);
 #endif
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     /* kill handle */
     HHRemoveHandle(handle);
     /* call NXflush */
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
     nxhandle =  (NXhandle)HHGetPointer(handle);
 #ifdef DEBUG
     fprintf(fd,"closing handle %d, nxhandle %d\n", handle, nxhandle);
+    fprintf(stderr,"closing handle %d, nxhandle %d\n", handle, nxhandle);
 #endif
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     if(iRet != NX_OK)
+    {
       fprintf(fd,"Cleanup code called after raising Exception\n");
+      fprintf(stderr,"Cleanup code called after raising Exception\n");
+    }
 #endif
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     if(iRet != NX_OK)
+    {
       fprintf(fd,"Cleanup code called after raising Exception\n");
+      fprintf(stderr,"Cleanup code called after raising Exception\n");
+    }
 #endif
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     if(iRet != NX_OK)
+    {
       fprintf(fd,"Cleanup code called after raising Exception\n");
+      fprintf(stderr,"Cleanup code called after raising Exception\n");
+    }
 #endif
 …
     (*env)->ReleaseStringUTFChars(env,path, nxpath);
+}
+/*-----------------------------------------------------------------------*/
+JNIEXPORT jstring JNICALL Java_org_nexusformat_NexusFile_nxgetpath
+  (JNIEnv *env, jobject obj, jint handle)
+{
+    NXhandle nxhandle;
+    int iRet;
+    char path[1024];
+    /* set error handler */
+    NXMSetTError(env,JapiError);
+    /* exchange the Java handler to a NXhandle */
+    nxhandle =  (NXhandle)HHGetPointer(handle);
+    iRet = NXgetpath(nxhandle, path,1024);
+    return (*env)->NewStringUTF(env,path);
+}
 /*------------------------------------------------------------------------
                      nxclosegroup
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
 #ifdef DEBUG
     fprintf(fd,"Compressing at %d with type %d\n", nxhandle, comp_type);
+    fprintf(stderr,"Compressing at %d with type %d\n", nxhandle, comp_type);
 #endif
     iRet = NXcompress(nxhandle,comp_type);
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     if(iRet != NX_OK)
+    {
         HEprint(fd,0);
+        HEprint(stderr,0);
+    }
 #endif
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     if(iRet != NX_OK)
+    {
         HEprint(fd,0);
+        HEprint(stderr,0);
+    }
 #endif
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     iargs = (*env)->GetIntArrayElements(env,args,0);
 #ifdef DEBUG
     fprintf(fd,"nxgetattr converted types \n");
+    fprintf(stderr,"nxgetattr converted types \n");
 #endif
 …
     iType = iargs[1];
 #ifdef DEBUG
     fprintf(fd,"nxgetattr: iLen %d, iType: %d\n",iLen, iType);
+    fprintf(stderr,"nxgetattr: iLen %d, iType: %d\n",iLen, iType);
 #endif
 …
     iargs[1] = iType;
 #ifdef DEBUG
     fprintf(fd,"nxgetattr cleaning up \n");
+    fprintf(stderr,"nxgetattr cleaning up \n");
 #endif
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
         if(cls == NULL)
+        {
             NXIReportError(env,
+            JapiError(env,
                "ERROR: failed to locate class in nxgetgroupid");
             return;
 …
         if(fid == 0)
+        {
             NXIReportError(env,
+            JapiError(env,
                "ERROR: failed to locate fieldID in nxgetgroupid");
             return;
 …
         if(fid == 0)
+        {
             NXIReportError(env,
+            JapiError(env,
                "ERROR: failed to locate fieldID in nxgetgroupid");
             return;
 …
         if(fid == 0)
+        {
             NXIReportError(env,
+            JapiError(env,
                "ERROR: failed to locate targetPath in nxgetgroupid");
             return;
 …
         if(fid == 0)
+        {
             NXIReportError(env,
+            JapiError(env,
                "ERROR: failed to locate linkType in nxgetgroupid");
             return;
 …
         if(fid == 0)
+        {
             NXIReportError(env,
+            JapiError(env,
                "ERROR: failed to locate targetPath in nxgetgroupid");
             return;
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
         if(cls == NULL)
+        {
             NXIReportError(env,
+            JapiError(env,
                "ERROR: failed to locate class in nxgetdataid");
             return;
 …
         if(fid == 0)
+        {
             NXIReportError(env,
+            JapiError(env,
                "ERROR: failed to locate fieldID in nxgetdataid");
             return;
 …
         if(fid == 0)
+        {
             NXIReportError(env,
+            JapiError(env,
                "ERROR: failed to locate fieldID in nxgetdataid");
             return;
 …
         if(fid == 0)
+        {
             NXIReportError(env,
+            JapiError(env,
                "ERROR: failed to locate targetPath in nxgetgroupid");
             return;
 …
         if(fid == 0)
+        {
             NXIReportError(env,
+            JapiError(env,
                "ERROR: failed to locate linkType in nxgetgroupid");
             return;
 …
         if(fid == 0)
+        {
             NXIReportError(env,
+            JapiError(env,
                "ERROR: failed to locate targetPath in nxgetdataid");
             return;
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     if(cls == NULL)
+    {
          NXIReportError(env,
+         JapiError(env,
                "ERROR: failed to locate class in nxmakelink");
          return;
 …
      if(fid == 0)
+     {
           NXIReportError(env,
+          JapiError(env,
                "ERROR: failed to locate fieldID in nxmakelink");
           return;
 …
      if(fid == 0)
+     {
           NXIReportError(env,
+          JapiError(env,
                "ERROR: failed to locate fieldID in nxmakelink");
           return;
 …
      if(fid == 0)
+     {
           NXIReportError(env,
+          JapiError(env,
                "ERROR: failed to locate targetPath in nxmakelink");
           return;
 …
      if(fid == 0)
+     {
           NXIReportError(env,
+          JapiError(env,
                "ERROR: failed to locate linkType in nxmakelink");
           return;
 …
      if(fid == 0)
+     {
           NXIReportError(env,
+          JapiError(env,
                "ERROR: failed to locate targetPath in nxmakelink");
           return;
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     if(cls == NULL)
+    {
          NXIReportError(env,
+         JapiError(env,
                "ERROR: failed to locate class in nxmakelink");
          return;
 …
      if(fid == 0)
+     {
           NXIReportError(env,
+          JapiError(env,
                "ERROR: failed to locate fieldID in nxmakelink");
           return;
 …
      if(fid == 0)
+     {
           NXIReportError(env,
+          JapiError(env,
                "ERROR: failed to locate fieldID in nxmakelink");
           return;
 …
      if(fid == 0)
+     {
           NXIReportError(env,
+          JapiError(env,
                "ERROR: failed to locate targetPath in nxmakelink");
           return;
 …
      if(fid == 0)
+     {
           NXIReportError(env,
+          JapiError(env,
                "ERROR: failed to locate linkType in nxmakelink");
           return;
 …
      if(fid == 0)
+     {
           NXIReportError(env,
+          JapiError(env,
                "ERROR: failed to locate targetPath in nxmakelink");
           return;
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
    /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
    /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
    /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     jint *jarray;
    /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
    /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
     /* set error handler */
     NXMSetError(env,JapiError);
+    NXMSetTError(env,JapiError);
     /* exchange the Java handler to a NXhandle */
 …
+    }
+}
+/*---------------------------------------------------------------------*/
+JNIEXPORT void JNICALL Java_org_nexusformat_NexusFile_initattrdir
+(JNIEnv *env, jobject obj, jint handle)
+{
+    NXhandle nxhandle;
+    int iRet;
+    /* set error handler */
+    NXMSetTError(env,JapiError);
+    /* exchange the Java handler to a NXhandle */
+    nxhandle =  (NXhandle)HHGetPointer(handle);
+    iRet = NXinitattrdir(nxhandle);
+}
+/*---------------------------------------------------------------------*/
+JNIEXPORT void JNICALL Java_org_nexusformat_NexusFile_initgroupdir
+(JNIEnv *env, jobject obj, jint handle)
+{
+    NXhandle nxhandle;
+    int iRet;
+    /* set error handler */
+    NXMSetTError(env,JapiError);
+    /* exchange the Java handler to a NXhandle */
+    nxhandle =  (NXhandle)HHGetPointer(handle);
+    iRet = NXinitgroupdir(nxhandle);
+}
 /*------------------------------------------------------------------------
                                debugstop
 …
+   }
+}

tags/4.2.1/bindings/java/org/nexusformat/NexusFile.java

                       r1896
+  *
   * copyright: see accompanying COPYRIGHT file
+  *
+  * added nxinitattrdir: Mark Koennecke, October 2009
   */
 package org.nexusformat;
 …
     protected native void close(int handle);
     protected native int  nxflush(int handle);
     /**
       * constructs a new NexusFile Object.
 …
     public NexusFile(String filename, int access) throws NexusException
+    {
+         checkForNull(filename);
          handle = init(filename,access);
          if(handle < 0){
 …
     protected native void nxopengrouppath(int handle, String path);
     protected native void nxclosegroup(int handle);
+    protected native String nxgetpath(int handle);
     /**
 …
                             NexusException
+    {
+        checkForNull(name, nxclass);
         if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
         nxmakegroup(handle, name, nxclass);
 …
+    {
         if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+        checkForNull(name, nxclass);
         nxopengroup(handle, name, nxclass);
+    }
 …
+    {
         if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+        nxopenpath(handle,path);
+        checkForNull(path);
+        nxopenpath(handle, path);
+    }
     /**
 …
+    {
         if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+        checkForNull(path);
         nxopengrouppath(handle,path);
+    }
+    /**
+     * return the current path into the NeXus file in the
+     * form of a Unix path string.
+     * @return A unix path string
+     */
+    public String getpath() throws NexusException
+    {
+        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+        return nxgetpath(handle);
+    }
     /**
       * closegroup closes access to the current group and steps down one
 …
                              NexusException {
         if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+        checkType(type);
+        checkType(type);
+        checkForNull(name);
         switch(compression_type) {
         case NexusFile.NX_COMP_NONE:
 …
       * @exception NexusException when the dataset could not be created.
       */
     public void makedata(String name, int type, int rank, int dim[]) throws
+    public void makedata(String name, int type, int rank, int[] dim) throws
                            NexusException
+    {
         if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
         checkType(type);
+        checkForNull(name, dim);
         nxmakedata(handle,name,type,rank,dim);
+    }
 …
+    {
         if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+        checkForNull(name);
         nxopendata(handle,name);
+    }
 …
         byte bdata[];
         if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+        checkForNull(array);
         try{
             HDFArray ha = new HDFArray(array);
 …
       * the data.
       */
     public void getslab(int start[], int size[],Object array)throws
+    public void getslab(int[] start, int[] size, Object array) throws
                           NexusException
+    {
         byte bdata[];
         if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+        checkForNull(start, size, array);
         try{
             HDFArray ha = new HDFArray(array);
             bdata = ha.emptyBytes();
             nxgetslab(handle,start,size,bdata);
+            nxgetslab(handle, start, size, bdata);
             array = ha.arrayify(bdata);
          }catch(HDFException he) {
 …
       * the attribute could not be found.
       */
     public void getattr(String name,Object array, int args[])throws
+    public void getattr(String name, Object array, int[] args)throws
                           NexusException
+    {
         byte bdata[];
         if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+        checkForNull(name, array, args);
         checkType(args[1]);
         try{
 …
        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+           checkForNull(array);
        try{
            HDFArray ha =  new HDFArray(array);
 …
       * @exception NexusException when an HDF error occurs.
       */
     public void putslab(Object array, int start[], int size[]) throws
+    public void putslab(Object array, int[] start, int[] size) throws
                           NexusException
+    {
 …
        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+       checkForNull(array, start, size);
        try{
            HDFArray ha =  new HDFArray(array);
 …
            throw new NexusException(he.getMessage());
+       }
        nxputslab(handle,data,start,size);
+       nxputslab(handle, data, start, size);
        data = null;
+    }
 …
        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
        checkType(iType);
+       checkForNull(name, array);
        try{
            HDFArray ha =  new HDFArray(array);
 …
     protected native int nextentry(int handle, String names[]);
     protected native int nextattr(int handle, String names[], int args[]);
+    protected native void initattrdir(int handle);
+    protected native void initgroupdir(int handle);
     /**
      * setnumberformat sets the number format for printing number when
 …
         throws NexusException{
        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+       checkType(type);
+       checkForNull(format);
        nxsetnumberformat(handle,type,format);
+    }
 …
         String names[] = new String[2];
         int i;
+        initgroupdir(handle);
         while(nextentry(handle,names) != -1)
+        {
 …
         Hashtable h = new Hashtable();
         if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+        initattrdir(handle);
         while(nextattr(handle,names,args) != -1)
+        {
 …
       * @exception NexusException if an error occurs.
       */
     public void   makelink(NXlink target)throws
+    public void makelink(NXlink target) throws
                           NexusException
+    {
       if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+      nxmakelink(handle,target);
+      checkForNull(target);
+      nxmakelink(handle, target);
+    }
     /**
 …
       * @exception NexusException if an error occurs.
       */
     public void   makenamedlink(String name, NXlink target)throws
+    public void makenamedlink(String name, NXlink target) throws
         NexusException {
       if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+      nxmakenamedlink(handle,name, target);
+      checkForNull(name, target);
+      nxmakenamedlink(handle, name, target);
+    }
 …
       * @exception NexusException if an error occurs.
       */
     public void   opensourcepath()throws
+    public void opensourcepath() throws
                           NexusException
+    {
 …
+    }
+    /**
+     * checks if any of the arguments is null,
+     * throws appropriate runtime exception if so
+     */
+    private void checkForNull(Object... args) {
+        for (Object o : args)
+                if (o==null) throw new NullPointerException();
+    }
     /**
       * checkType verifies if a parameter is a valid NeXus type code.
 …
+    {
         switch(type) {
+        case NexusFile.NX_FLOAT32:
+        case NexusFile.NX_FLOAT64:
         case NexusFile.NX_INT8:
         case NexusFile.NX_UINT8:
-        case NexusFile.NX_CHAR:
         case NexusFile.NX_INT16:
         case NexusFile.NX_UINT16:
         case NexusFile.NX_INT32:
         case NexusFile.NX_UINT32:
+        case NexusFile.NX_FLOAT32:
+        case NexusFile.NX_FLOAT64:
+        case NexusFile.NX_INT64:
+        case NexusFile.NX_UINT64:
+        case NexusFile.NX_CHAR:
             break;
         default:
 …
      * @throws NexusException if things are wrong
      */
+    public void linkexternal(String name, String nxclass, String nxurl) throws NexusException{
+        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+        nxlinkexternal(handle,name,nxclass,nxurl);
+    public void linkexternal(String name, String nxclass, String nxurl) throws NexusException {
+        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+        checkForNull(name, nxclass, nxurl);
+        nxlinkexternal(handle, name, nxclass, nxurl);
+    }
     /**
 …
     public String isexternalgroup(String name, String nxclass) throws NexusException{
         if(handle < 0) throw new NexusException("NAPI-ERROR: File not open");
+        checkForNull(name, nxclass);
         String nxurl[] = new String[1];
 …
     public native void debugstop();
+}

tags/4.2.1/bindings/java/org/nexusformat/NeXusFileInterface.java

                       r1896
     public void opengrouppath(String path) throws
                            NexusException;
+    /**
+     * return the current path into the NeXus file in the
+     * form of a Unix path string.
+     * @return A unix path string
+     */
+    public String getpath() throws NexusException;
     /**
       * closegroup closes access to the current group and steps down one

tags/4.2.1/bindings/python/Makefile.am

r1896	r1896
35	35	#pkgpython_PYTHON = nxstest.py
36	36	nxspython_PYTHON = nxs/__init__.py nxs/napi.py
37		EXTRA_DIST = README.html nxstest.py run_nxstest
	37	EXTRA_DIST = README.html nxstest.py run_nxstest setup.py
38	38
39	39	install-data-hook :

tags/4.2.1/bindings/cpp/NeXusFile.cpp

                       r1896
+  }
+  template<>
+  NXDLL_EXPORT NXnumtype getType(char number) {
+    stringstream msg;
+    msg << "NeXus::getType() does not know type of \"char\" " << number;
+    throw Exception(msg.str());
+  }
   // template specialisations for types we know
   template<>
 …
     return UINT64;
+  }
+}
 …
     throw Exception(msg.str(), status);
+  }
+}
+std::string File::getPath(){
+  char cPath[1024];
+  memset(cPath,0,1024*sizeof(char));
+  NXstatus status = NXgetpath(this->m_file_id,cPath, 1024);
+  if (status != NX_OK) {
+    stringstream msg;
+    msg << "NXgetpath() failed";
+    throw Exception(msg.str(), status);
+  }
+  return std::string(cPath);
+}

tags/4.2.1/bindings/cpp/NeXusFile.hpp

                       r1896
      */
     void openGroupPath(const std::string& path);
+    /**
+     * Get the path into the current file
+     * \return A unix like path string pointing to the current
+     *         position in the file
+     */
+    std::string  getPath();
     /**

tags/4.2.1/bindings/cpp/Makefile.am

r1896	r1896
35	35	LIBNEXUS=$(top_builddir)/src/libNeXus.la
36	36	lib_LTLIBRARIES=libNeXusCPP.la
	37	AM_LDFLAGS=-version-info $(NXLTVERSINFO)
37	38
38	39	# nxincludedir=$(includedir)/nexus

tags/4.2.1/bindings/f77/napif.inc

                       r1896
 C *** large enough to hold an NXhandle structure
       INTEGER NXHANDLESIZE
+      PARAMETER(NXHANDLESIZE=5120)
+C      PARAMETER(NXHANDLESIZE=5120)
+      PARAMETER(NXHANDLESIZE=9058)
 C *** NXLINKSIZE is (at least) the size of an INTEGER*4 array that can hold
 C *** an NXlink structure: we'll assume 64bit alignment of structure members for safety
 …
      +       NXINITATTRDIR, NXFLUSH, NXCOMPMAKEDATA, NXOPENPATH,
      +       NXSETNUMBERFORMAT, NXOPENGROUPPATH, NXOPENSOURCEGROUP,
      +       NXMAKENAMEDLINK
+     +       NXMAKENAMEDLINK, NXGETPATH
       LOGICAL NXSAMEID
       EXTERNAL NXOPEN, NXCLOSE, NXMAKEGROUP, NXOPENGROUP, NXCLOSEGROUP,
 …
      +       NXOPENPATH,NXSETNUMBERFORMAT, NXOPENGROUPPATH,
      +       NXOPENSOURCEGROUP, NXINQUIREFILE, NXISEXTERNALGROUP,
      +       NXLINKEXTERNAL, NXMAKENAMEDLINK
+     +       NXLINKEXTERNAL, NXMAKENAMEDLINK, NXGETPATH

tags/4.2.1/bindings/f77/Makefile.am

r1896	r1896
29	29	#====================================================================
30	30	lib_LTLIBRARIES=libNeXus77.la
	31	AM_LDFLAGS=-version-info $(NXLTVERSINFO)
31	32
32	33	libNeXus77_la_SOURCES=napif.f

tags/4.2.1/bindings/f77/napif.f

                       r1896
       CALL EXTRACT_STRING(IPATH, 256, PATH)
       NXOPENPATH = NXIOPENPATH(FILEID, IPATH)
+      END
+      INTEGER FUNCTION NXGETPATH(FILEID, PATH)
+      INTEGER FILEID(*),NXIGETPATH, NXIFGETPATH
+      CHARACTER*(*) PATH
+      INTEGER*1 IPATH(1024)
+      INTEGER PLEN
+      EXTERNAL NXIFGETPATH
+      PLEN = 1024
+      NXGETPATH = NXIFGETPATH(FILEID,IPATH,PLEN)
+      CALL REPLACE_STRING(PATH,IPATH)
       END

tags/4.2.1/configure.ac

                       r1896
 AC_PREREQ(2.61)
 AC_REVISION($Revision$)
 AC_INIT([NeXus Library], [4.2.0], [nexus-developers@nexusformat.org], [nexus])
+AC_INIT([NeXus Library], [4.2.1], [nexus-developers@nexusformat.org], [nexus])
 AC_COPYRIGHT([Copyright (C) 2004 NeXus International Advisory Committee
 This software is covered by the GNU LESSER GENERAL PUBLIC LICENSE
 see file COPYING for further information])
+# used by libtool - need to get if from 4.2.1 better
+NXLTVERSINFO="4:2:4"
 AC_CONFIG_AUX_DIR(config)
 …
 AM_INIT_AUTOMAKE([1.6])
+AC_SUBST(NXLTVERSINFO)
 AM_CONFIG_HEADER(include/nxconfig.h:include/nxconfig_h.in)
 …
 fi
+AC_SUBST(WITH_F77)
 AC_ARG_WITH([f77], AC_HELP_STRING([--with-f77=f77 compiler], [Specify name of FORTRAN 77 compiler]),
         [with_f77=$withval], [with_f77=no])
 if test x"$with_f77" != x"no" ; then
+        [], [with_f77=no])
+if test ! -z "$with_f77" -a x"$with_f77" != x"no" ; then
         if test x"$with_f77" != x"yes" ; then F77="$with_f77"; fi
         AC_PROG_F77
 …
         AC_CHECK_F77_OPTION([-I$mytop/bindings/f77],[      INCLUDE 'napif.inc'])
         AC_F77_LIBRARY_LDFLAGS
+        WITH_F77=yes
 else
         F77=
+fi
+        WITH_F77=no
+fi
+AC_SUBST(WITH_F90)
 AC_ARG_WITH([f90], AC_HELP_STRING([--with-f90=f90 compiler], [Specify name of FORTRAN 90 compiler]),
         [with_f90=$withval], [with_f90=no])
 if test x"$with_f90" != x"no" ; then
+        [], [with_f90=no])
+if test ! -z "$with_f90" -a x"$with_f90" != x"no" ; then
         if test x"$with_f90" = x"yes" ; then
                 AC_CHECK_PROGS(FC, [g95 f90 f95 ifort])
+                AC_CHECK_PROGS(FC, [g95 gfortran f90 f95 ifort])
         else
                 FC="$with_f90"
 …
 #        if test x$with_f77=xno; then with_f77=$FC; fi
 #        if test x$with_f77=xno; then with_f77=yes; fi
+        WITH_F90=yes
 else
         FC=
+fi
+        WITH_F90=no
+fi
+AC_ARG_WITH([matlabroot], AC_HELP_STRING([--with-matlabroot=path to matlab install dir], [Specify location of matlab installation directory]),
+        [], [with_matlabroot=no])
+if test x"$with_matlabroot" != x"no" ; then
+    MATLABROOT="$with_matlabroot"
+fi
+AC_PATH_PROG(MATLAB,matlab,[],[$MATLABROOT/bin:/usr/local/matlab/bin:/opt/matlab/bin:$PATH])
+if test x"$MATLABROOT" = x -a x"$MATLAB" != x; then
+    MATLABROOT=`dirname $MATLAB`/..
+fi
+dnl thread local storage
+AC_MSG_CHECKING([for __thread])
+AC_LINK_IFELSE([AC_LANG_PROGRAM([#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) && ((__GNUC__ < 4) || (__GNUC__ == 4 && __GNUC__MINOR__ < 1) || (__GNUC__ == 4 && __GNUC__MINOR__ == 1 && __GNUC_PATCHLEVEL__ < 2))
+#endif], [static __thread int p = 0])],
+               [AC_DEFINE(HAVE_TLS, 1,
+                      Define to 1 if compiler supports __thread)
+                AC_MSG_RESULT([yes])],
+               [AC_MSG_RESULT([no])])
 java_host="linux"
 …
 AC_ARG_WITH([java-home], AC_HELP_STRING([--with-java-home=JAVA SDK Home], [Specify location of top directory of JAVA SDK i.e. where the bin, lib and include directories live]),
         [], [with_java_home=$withval])
+AC_ARG_WITH([java], AC_HELP_STRING([--with-java=path to java executable], [Specify location of JAVA executable]),
+        [], [with_java=no])
+if test -z "$with_java_home" -a x$with_java != xno; then
+    def_javac=`which javac`
+    link_javac=`readlink -e "$def_javac"`
+    with_java_home=`dirname "$link_javac"`/..
+fi
 if test -d "$with_java_home"; then
         JAVAROOT="$with_java_home"
         AC_MSG_NOTICE([Java SDK home is $JAVAROOT])
         JAVAINCLUDE="-I$JAVAROOT/include"
         AC_PATH_PROGS(JAVAC,gcj javac,,[$JAVAROOT/bin])
+        AC_PATH_PROGS(JAVAC,javac gcj,,[$JAVAROOT/bin])
         if test `basename "$JAVAC"` = "gcj"; then
             JAVACFLAGS="-C"     # force creation of .class files
         fi
         AC_PATH_PROGS(JAVA,gij java,,[$JAVAROOT/bin])
         AC_PATH_PROGS(JAVAH,gcjh javah,,[$JAVAROOT/bin])
+        AC_PATH_PROGS(JAVA,java gij,,[$JAVAROOT/bin])
+        AC_PATH_PROGS(JAVAH,javah gcjh,,[$JAVAROOT/bin])
         AC_PATH_PROGS(JAVADOC,javadoc,,[$JAVAROOT/bin:$PATH])
         AC_PATH_PROGS(JAR,jar fastjar,,[$JAVAROOT/bin:$PATH])
 …
 test -z "$PACKAGE_RELEASE" && PACKAGE_RELEASE=1
+SHARED_LDFLAGS=""
 NXDOCDIR='${datadir}/nexus/doc'
 NXEXAMPLEDIR='${datadir}/nexus/examples'
 …
     fi
     AM_PATH_PYTHON(,, :)
+    AC_CHECK_PYTHON_MODULE(numpy)
 fi
 …
 # strict aliasing causes issues with casts from NXmalloc()
 CFLAGS="-fno-strict-aliasing"
 CXXFLAGS="-fno-strict-aliasing"
+CFLAGS="$CFLAGS -fno-strict-aliasing"
+CXXFLAGS="$CXXFLAGS -fno-strict-aliasing"
 # check for debug
 …
     *mingw*)
         SHARED_LDFLAGS="-no-undefined" #  -Wl,--add-stdcall-alias
+        SHARED_LDFLAGS="$SHARED_LDFLAGS -no-undefined" #  -Wl,--add-stdcall-alias
         MINGW_MSYS=yes
         HDF_EXT=dll
 …
     *cygwin*)
 #       SHARED_LDFLAGS="-no-undefined" #  -Wl,--add-stdcall-alias
+#       SHARED_LDFLAGS="$SHARED_LDFLAGS -no-undefined" #  -Wl,--add-stdcall-alias
         ;;
 …
 dnl     F90FLAGS="$F90FLAGS -g -cons -YEXT_NAMES=LCS -YEXT_SFX=_"
 dnl     FCFLAGS="$FCFLAGS -qextname"
         SHARED_LDFLAGS="-Wl,-single_module"
+        SHARED_LDFLAGS="$SHARED_LDFLAGS -Wl,-single_module"
 #       LTF90COMPILETAG="--tag=F77"
 #       LTF90LINKTAG="--tag=CC"
 …
 fi
 # for Mac/fink when hdf and hdf5 are not taken from fink, but jpeg is
 if test -d /sw/lib; then
     LDFLAGS="$LDFLAGS -L/sw/lib"
 fi
+#if test -d /sw/lib; then
+#    LDFLAGS="$LDFLAGS -L/sw/lib"
+#fi
 # for Mac/Macports when you are not using fink at all.
 if test -d /opt/local/lib; then
     LDFLAGS="$LDFLAGS -L/opt/local/lib"
 fi
+#if test -d /opt/local/lib; then
+#    LDFLAGS="$LDFLAGS -L/opt/local/lib"
+#fi
 # remove initial :
 …
 AC_CHECK_LIB(hdf5, H5open)
 AC_CHECK_LIB(xml2, xmlParseDocument)
+AC_CHECK_LIB(readline, readline)
+AC_CHECK_LIB(history, add_history)
+dnl AC_LANG_PUSH([C++])
+dnl AC_CHECK_LIB(mxmlplus, _ZN4MXML4NodeD2Ev)
+dnl AC_LANG_POP([C++])
 dnl Checks for header files.
 …
 AC_TYPE_LONG_LONG_INT
 AC_TYPE_UNSIGNED_LONG_LONG_INT
+AC_CHECK_SIZEOF([int])
+AC_CHECK_SIZEOF([long int])
+AC_CHECK_SIZEOF([long long int])
+dnl these are not compatible with cross architecture compiling
+if test x$cross_compiling != xyes; then
+    AC_CHECK_SIZEOF([int])
+    AC_CHECK_SIZEOF([long int])
+    AC_CHECK_SIZEOF([long long int])
+fi
 AC_STRUCT_TM
 …
 AC_CHECK_FUNCS([ftime memset strchr strdup strrchr strstr tzset mkstemp])
+AC_CHECK_FUNC([rl_completion_matches])
 AM_CONDITIONAL(HAVE_CPP, [test ! -z "$CXX"])
 AM_CONDITIONAL(HAVE_F77, [test "$with_f77" != "no"])
 AM_CONDITIONAL(HAVE_F90, [test "$with_f90" != "no"])
 AM_CONDITIONAL(HAVE_PYTHON, [test ! -z "$PYTHONROOT"])
+AM_CONDITIONAL(HAVE_PYTHON, [test ! -z "$PYTHONROOT" -a "$PYTHON_numpy" -eq 1])
 AM_CONDITIONAL(HAVE_TCL, [test ! -z "$TCLROOT"])
 AM_CONDITIONAL(HAVE_GUILE, [test ! -z "$GUILEROOT"])
 …
 AM_CONDITIONAL(HAVE_XML, [test ! -z "$MXMLROOT"])
 AM_CONDITIONAL(HAVE_LIBXML2, [ test "$ac_cv_lib_xml2_xmlParseDocument" = "yes" ])
+dnl AM_CONDITIONAL(HAVE_LIBMXMLPLUS, [ test "$ac_cv_lib_mxmlplus__ZN4MXML4NodeD2Ev" = "yes" ])
 AM_CONDITIONAL(HAVE_DOCBOOK, [test ! -z "$DOCBOOK2TXT" -a ! -z "$DOCBOOK2PDF"])
 AM_CONDITIONAL(HAVE_LATEX, [test ! -z "$LATEX"])
 …
                 doc/Makefile
                 doc/doxygen/Makefile
-                doc/doxygen/Doxyfile
                 doc/api/Makefile
                 doc/nxdict/Makefile
 …
                 contrib/bindings/Makefile
                 contrib/bindings/python/Makefile
+                macosx_install_kit/Makefile
+                macosx_install_kit/pkg.config
                 scripts/Makefile
                 scripts/nexus.pc:scripts/nexus_pc.in
 …
 JAVABINDING=`if test -n "$JAVAROOT" ; then echo yes ; else echo no ; fi`
 IDLBINDING=`if test -n "$IDLROOT" ; then echo yes ; else echo no ; fi`
 PYTHONBINDING=`if test -n "$PYTHONROOT" ; then echo yes; else echo no ; fi`
+PYTHONBINDING=`if test -n "$HAVE_PYTHON_FALSE"; then echo yes; else echo no ; fi`
 if test -n "$SWIG" ; then
     SWIGBINDING="yes ("
 …
                 SWIG:          ${SWIGBINDING}
                  IDL:          ${IDLBINDING} (--with-idlroot=${IDLROOT}, --with-idldlm=${IDLDLM})
               PYTHON:          ${PYTHONBINDING} (PYTHONROOT=${PYTHONROOT})
+              PYTHON:          ${PYTHONBINDING} (PYTHONROOT=${PYTHONROOT}, numpy found: $PYTHON_numpy_found)
         documentation:

tags/4.2.1/doc

Property svn:mergeinfo set to
/trunk/doc merged eligible

tags/4.2.1/doc/doxygen/Makefile.am

                       r1896
 if HAVE_PDFLATEX
 if HAVE_DOT
+        rm -fr latex html
+        $(DOXYGEN) Doxyfile
+        ( cd latex; make pdf )
+        rm -fr latex html latex-* html-*
+        env TOPSRC=$(top_srcdir) $(DOXYGEN) $(srcdir)/Doxyfile_c
+        ( cd latex-c; ) # ( cd latex-c; make pdf )
+        env TOPSRC=$(top_srcdir) $(DOXYGEN) $(srcdir)/Doxyfile_cpp
+        ( cd latex-cpp; ) # ( cd latex-cpp; make pdf )
+        env TOPSRC=$(top_srcdir) $(DOXYGEN) $(srcdir)/Doxyfile_java
+        ( cd latex-java; ) # ( cd latex-java; make pdf )
+        env TOPSRC=$(top_srcdir) $(DOXYGEN) $(srcdir)/Doxyfile_python
+        ( cd latex-python; ) # ( cd latex-python; make pdf )
+        env TOPSRC=$(top_srcdir) $(DOXYGEN) $(srcdir)/Doxyfile_f90
+        ( cd latex-f90; ) # ( cd latex-f90; make pdf )
+        env TOPSRC=$(top_srcdir) $(DOXYGEN) $(srcdir)/Doxyfile_f77
+        ( cd latex-f77; ) # ( cd latex-f77; make pdf )
         rm -f refman.pdf
         ln -s latex/refman.pdf .
+        ln -s latex-c/refman.pdf .
 endif
 endif
 …
         touch doxy.remove_me_to_remake
+dist-hook :
 if HAVE_DOXYGEN
 if HAVE_PDFLATEX
 if HAVE_DOT
+dist-hook :
+        test -f $(srcdir)/refman.pdf && cp $(srcdir)/refman.pdf $(distdir)
+        if test -d $(srcdir)/html; then \
+                cp -r $(srcdir)/html $(distdir); \
+                find $(distdir)/html -depth -type d -name '.svn' -exec rm -fr {} \; ;\
+        if test -f $(srcdir)/refman.pdf; then \
+            cp $(srcdir)/refman.pdf $(distdir); \
         fi
+install-data-local :
+        $(mkinstalldirs) $(DESTDIR)$(nxdoxydir)
+        test -f $(srcdir)/refman.pdf && cp $(srcdir)/refman.pdf $(DESTDIR)$(nxdoxydir)
+        if test -d $(srcdir)/html; then \
+                cp -r $(srcdir)/html $(DESTDIR)$(nxdoxydir); \
+                find $(DESTDIR)$(nxdoxydir) -type f -exec chmod 0644 {} \; ;\
+                find $(DESTDIR)$(nxdoxydir) -type d -exec chmod 0755 {} \; ;\
+        if test -d $(srcdir)/html-c; then \
+          for i in $(srcdir)/html-*; do \
+            if test -d $$i; then \
+                cp -r $$i $(distdir); \
+            fi; \
+          done; \
+          find $(distdir)/html-* -depth -type d -name '.svn' -exec rm -fr {} \; ; \
         fi
 endif
 …
 endif
+install-data-local :
+        $(mkinstalldirs) $(DESTDIR)$(nxdoxydir)
+        if test -f $(srcdir)/refman.pdf; then \
+            cp $(srcdir)/refman.pdf $(DESTDIR)$(nxdoxydir); \
+        fi
+        if test -d $(srcdir)/html-c; then \
+          for i in $(srcdir)/html-*; do \
+                cp -r $$i $(DESTDIR)$(nxdoxydir); \
+          done; \
+          find $(DESTDIR)$(nxdoxydir) -type f -exec chmod 0644 {} \; ;\
+          find $(DESTDIR)$(nxdoxydir) -type d -exec chmod 0755 {} \; ;\
+        fi
 clean-local :
         rm -fr html latex refman.pdf
+        rm -fr html-* latex-* refman.pdf
 uninstall-local :
         rm -fr $(DESTDIR)$(nxdoxydir)
+EXTRA_DIST=$(srcdir)/Doxyfile_*

tags/4.2.1/doc/tech_ref/methods.docbook

                       r1896
 definition.</para></listitem>
 <listitem id="method.ol.write_file"><para>Write a sample NeXus file
+<listitem id="method.ol.write-file"><para>Write a sample NeXus file
 conforming to the instrument definition (for example, using
 NXtranslate).</para></listitem>
 …
 <listitem id="method.ol.test"><para>Test the file, repeating steps
 <xref linkend="method.ol.niac"> and <xref
 linkend="method.ol.write_file"> as appropriate.</para></listitem>
+linkend="method.ol.write-file"> as appropriate.</para></listitem>
 <listitem id="method.ol.ratify"><para>Request ratification once the

tags/4.2.1/doc/tech_ref/base_classes.docbook

                       r1896
 <!-- ******************** BASE CLASSES ******************** -->
 <chapter id="base_classes"><title>Base Classes</title>
+<chapter id="base-classes"><title>Base Classes</title>
 <para>This chapter will list all of the base classes and their
 …
 </example>
 <example id="NXbeam_stop.xml"><title><filename>NXbeam_stop.xml</filename></title>
+<example id="NXbeam-stop.xml"><title><filename>NXbeam_stop.xml</filename></title>
 <programlisting role="XML">
 <![CDATA[<!--
 …
 </example>
 <example id="NXdisk_chopper.xml"><title><filename>NXdisk_chopper.xml</filename></title>
+<example id="NXdisk-chopper.xml"><title><filename>NXdisk_chopper.xml</filename></title>
 <programlisting role="XML">
 <![CDATA[<!--
 …
 </example>
 <example id="NXevent_data.xml"><title><filename>NXevent_data.xml</filename></title>
+<example id="NXevent-data.xml"><title><filename>NXevent_data.xml</filename></title>
 <programlisting role="XML">
 <![CDATA[<!--
 …
 </example>
 <example id="NXfermi_chopper.xml"><title><filename>NXfermi_chopper.xml</filename></title>
+<example id="NXfermi-chopper.xml"><title><filename>NXfermi_chopper.xml</filename></title>
 <programlisting role="XML">
 <![CDATA[<!--
 …
 </example>
 <example id="NXvelocity_selector.xml"><title><filename>NXvelocity_selector.xml</filename></title>
+<example id="NXvelocity-selector.xml"><title><filename>NXvelocity_selector.xml</filename></title>
 <programlisting role="XML">
 <![CDATA[<!--

tags/4.2.1/doc/tech_ref/tofnpd.docbook

r1896	r1896
45	45	</para>
46	46
47		<example id="TOFNPD-time_focus.xml"><title><filename>TOFNPD:time_focus.xml</filename></title>
	47	<example id="TOFNPD-time-focus.xml"><title><filename>TOFNPD:time_focus.xml</filename></title>
48	48	<programlisting role="XML">
49	49	<![CDATA[<!--

tags/4.2.1/doc/tech_ref/NeXus_definitions.docbook

                       r1896
  <!ENTITY terminology  SYSTEM "terminology.docbook">
  <!ENTITY methods      SYSTEM "methods.docbook">
  <!ENTITY base_classes SYSTEM "base_classes.docbook">
+ <!ENTITY base-classes SYSTEM "base_classes.docbook">
  <!ENTITY monoref      SYSTEM "monoref.docbook">
  <!ENTITY monotas      SYSTEM "monotas.docbook">
 …
  <!ENTITY nxtranslate  "<application>NXtranslate</application>">
  <!ENTITY napi         "<acronym>napi</acronym>">
  <!ENTITY mime_type    "<parameter>NXS:mime_type</parameter>">
+ <!ENTITY mime-type    "<parameter>NXS:mime_type</parameter>">
  <!ENTITY source       "<parameter>NXS:source</parameter>">
  <!ENTITY location     "<parameter>NXS:location</parameter>">
  <!ENTITY make_link    "<parameter>target</parameter>">
  <!ENTITY link_tag     "<parameter>NAPIlink</parameter>">
+ <!ENTITY make-link    "<parameter>target</parameter>">
+ <!ENTITY link-tag     "<parameter>NAPIlink</parameter>">
 ]>
 …
 <!-- ******************** BASE CLASSES ******************** -->
 &base_classes
+&base-classes
 <!-- ******************** DEFINITIONS ******************** -->

tags/4.2.1/NEWS

                       r1896
+For the latest information see
+    http://www.nexusformat.org/Nexus_42_Release_Notes
+Version 4.2.1
+=============
+The following new featues have been added:
+* NXbrowse now has readline support (i.e. previous command line recall and
+  TAB completion of entry names)
+* new API functions NXgetpath() and NXgetversion() added
+* NXgetnextentry() now uses less stack space
 Version 4.2.0
 =============
-For the latest information see
-    http://www.nexusformat.org/Nexus_42_Release_Notes
 ==System Requirements==

tags/4.2.1/test

Property svn:mergeinfo set to
/trunk/test merged eligible

tags/4.2.1/test/napif4_test.f

                       r1896
       INCLUDE 'napif.inc'
       INTEGER NXRANK, NXDIMS(NX_MAXRANK), NXTYPE, NXLEN
       INTEGER ENTRY_STATUS, ATTR_STATUS
+      INTEGER ENTRY_STATUS, ATTR_STATUS, STAT
       INTEGER*4 I, J
       REAL*4 R
 …
       CHARACTER*128 CHAR_BUFFER
       INTEGER*1 CHAR_BUFFER_B(128)
       CHARACTER*64 GROUP_NAME, CLASS_NAME
+      CHARACTER*64 GROUP_NAME, CLASS_NAME, PATH
       INTEGER FILEID(NXHANDLESIZE)
       INTEGER GLINK(NXLINKSIZE), DLINK(NXLINKSIZE), BLINK(NXLINKSIZE)
 …
                      IF (NXPUTSLAB(FILEID, U_BUFFER(I), SLAB_START,
      +                 SLAB_SIZE) .NE. NX_OK) STOP
+                     STAT = NXCLOSEDATA(FILEID)
                      IF (NXFLUSH(FILEID) .NE. NX_OK) STOP
                END DO
 …
       ELSE IF (ENTRY_STATUS .EQ. NX_OK) THEN
          IF (NXOPENDATA(FILEID,NAME) .NE. NX_OK) STOP
+         IF(NXGETPATH(FILEID,PATH) .NE. NX_OK) STOP
+         WRITE(*,FMT='(1X,A,A)') 'Path = ', PATH(1:LEN_TRIM(PATH))
          IF (NXGETINFO(FILEID,NXRANK,NXDIMS,NXTYPE) .NE. NX_OK) STOP
          WRITE(*,FMT='(4X,A,I2,A)') NAME(1:LEN_TRIM(NAME))//'(',

tags/4.2.1/test/napif5_test.f

                       r1896
       INCLUDE 'napif.inc'
       INTEGER NXRANK, NXDIMS(NX_MAXRANK), NXTYPE, NXLEN
       INTEGER ENTRY_STATUS, ATTR_STATUS
+      INTEGER ENTRY_STATUS, ATTR_STATUS, STAT
       INTEGER*4 I, J
       REAL*4 R
 …
       INTEGER*1 CHAR_BUFFER_B(128)
       CHARACTER*64 GROUP_NAME, CLASS_NAME
+      CHARACTER*70 PATH
       INTEGER FILEID(NXHANDLESIZE)
       INTEGER GLINK(NXLINKSIZE), DLINK(NXLINKSIZE), BLINK(NXLINKSIZE)
 …
                      IF (NXPUTSLAB(FILEID, U_BUFFER(I), SLAB_START,
      +                 SLAB_SIZE) .NE. NX_OK) STOP
+                     STAT = NXCLOSEDATA(FILEID)
                      IF (NXFLUSH(FILEID) .NE. NX_OK) STOP
                END DO
 …
       ELSE IF (ENTRY_STATUS .EQ. NX_OK) THEN
          IF (NXOPENDATA(FILEID,NAME) .NE. NX_OK) STOP
+         IF(NXGETPATH(FILEID,PATH) .NE. NX_OK) STOP
+         WRITE(*,FMT='(1X,A,A)') 'Path = ', PATH(1:LEN_TRIM(PATH))
          IF (NXGETINFO(FILEID,NXRANK,NXDIMS,NXTYPE) .NE. NX_OK) STOP
          WRITE(*,FMT='(4X,A,I2,A)') NAME(1:LEN_TRIM(NAME))//'(',

tags/4.2.1/test/napi_test.c

                       r1896
   int64_t grossezahl[4];
   const char* ch_test_data = "NeXus ><}&{'\\&\" Data";
+  char path[512];
   grossezahl[0] = 12;
 …
   NXgetattrinfo(fileid,&i);
   printf("Number of group attributes: %d\n", i);
+  if(NXgetpath(fileid,path,512) != NX_OK)return 1;
+  printf("NXentry path %s\n", path);
   do {
      attr_status = NXgetnextattr (fileid, name, NXdims, &NXtype);
 …
         if (entry_status == NX_OK) {
            if (NXopendata (fileid, name) != NX_OK) return 1;
+              if (NXgetinfo (fileid, &NXrank, NXdims, &NXtype) != NX_OK) return 1;
+            if(NXgetpath(fileid,path,512) != NX_OK)return 1;
+            printf("Data path %s\n", path);
+            if (NXgetinfo (fileid, &NXrank, NXdims, &NXtype) != NX_OK) return 1;
                  printf ("   %s(%d)", name, NXtype);
               if (NXmalloc ((void **) &data_buffer, NXrank, NXdims, NXtype) != NX_OK) return 1;
 …
   if (NXopengroup (fileid, "link", "NXentry") != NX_OK) return 1;
     if (NXopengroup (fileid, "sample", "NXsample") != NX_OK) return 1;
+    if(NXgetpath(fileid,path,512) != NX_OK)return 1;
+    printf("Group path %s\n", path);
       if (NXgetgroupID (fileid, &blink) != NX_OK) return 1;
         if (NXsameID(fileid, &glink, &blink) != NX_OK)

tags/4.2.1/test/napif_test.f

                       r1896
       INTEGER*1 CHAR_BUFFER_B(128)
       CHARACTER*64 GROUP_NAME, CLASS_NAME
+      CHARACTER*70 PATH
       INTEGER FILEID(NXHANDLESIZE)
       INTEGER GLINK(NXLINKSIZE), DLINK(NXLINKSIZE), BLINK(NXLINKSIZE)
 …
       ELSE IF (ENTRY_STATUS .EQ. NX_OK) THEN
          IF (NXOPENDATA(FILEID,NAME) .NE. NX_OK) STOP
+         IF (NXGETPATH(FILEID,PATH) .NE. NX_OK)STOP
+         WRITE(*,FMT='(1X,A,A)') 'Path = ', PATH(1:LEN_TRIM(PATH))
          IF (NXGETINFO(FILEID,NXRANK,NXDIMS,NXTYPE) .NE. NX_OK) STOP
          WRITE(*,FMT='(4X,A,I2,A)') NAME(1:LEN_TRIM(NAME))//'(',

tags/4.2.1/test/atlocal.in

                       r1896
 export HAVE_XML
+#
 if test ! -z "@F77@"; then
+if test "@WITH_F77@" = "yes"; then
     HAVE_F77=run_test
 else
 …
 export HAVE_F77
+#
 if test ! -z "@FC@"; then
+if test "@WITH_F90@" = "yes"; then
     HAVE_F90=run_test
 else

tags/4.2.1/test/napi_test_cpp.cxx

                       r1896
 #include <cstring>
 #include <cstdlib>
+#include <cstdio>
 #include <vector>
 #include "napiconfig.h"
 …
         cout << toString(result);
+      }
+      cout <<  endl;
+      cout << "   Path = " << file.getPath() << endl;
+      file.closeData();
+    }
     else {
+      cout << ":" << it->second;
+    }
+    cout <<  endl;
+      cout << ":" << it->second << endl;
+    }
+  }
   file.closeGroup();

tags/4.2.1/test/testsuite.at

                       r1896
 [[NXinquirefile found: NXtest.hdf
 Number of global attributes: 4
    NeXus_version = 4.2.0
+   NeXus_version = 4.2.1
    file_name = NXtest.hdf
 Number of group attributes: 2
+NXentry path /entry
    hugo = namenlos
    cucumber = passion
 Group: entry(NXentry) contains 9 items
+Data path /entry/ch_data
    ch_data(4) = NeXus ><}&{'\&" Data
+Data path /entry/c1_data
    c1_data(4) = abcdefghijklmnopqrst
+Data path /entry/i1_data
    i1_data(20) =  1 2 3 4
+Data path /entry/i2_data
    i2_data(22) =  1000 2000 3000 4000
+Data path /entry/i4_data
    i4_data(24) =  1000000 2000000 3000000 4000000
+Data path /entry/r4_data
    r4_data(5)
 .000000 2.000000 3.000000 4.000000
 …
 .000000 14.000000 15.000000 16.000000
 .000000 18.000000 19.000000 20.000000
+Data path /entry/r8_data
    r8_data(6)
 .000000 2.000000 3.000000 4.000000
 …
    Subgroup: data(NXdata)
    Subgroup: sample(NXsample)
+Group path /link/sample
 Link check OK
 NXopenpath checks OK
 …
 [[NXinquirefile found: NXtest.h5
 Number of global attributes: 4
    NeXus_version = 4.2.0
+   NeXus_version = 4.2.1
    file_name = NXtest.h5
 Number of group attributes: 2
+NXentry path /entry
    hugo = namenlos
    cucumber = passion
 Group: entry(NXentry) contains 10 items
+Data path /entry/c1_data
    c1_data(4) = abcdefghijklmnopqrst
+Data path /entry/ch_data
    ch_data(4) = NeXus ><}&{'\&" Data
    Subgroup: data(NXdata)
+Data path /entry/grosse_zahl
    grosse_zahl(26) =  12 555555555555 23 777777777777
+Data path /entry/i1_data
    i1_data(20) =  1 2 3 4
+Data path /entry/i2_data
    i2_data(22) =  1000 2000 3000 4000
+Data path /entry/i4_data
    i4_data(24) =  1000000 2000000 3000000 4000000
+Data path /entry/r4_data
    r4_data(5)
 .000000 2.000000 3.000000 4.000000
 …
 .000000 14.000000 15.000000 16.000000
 .000000 18.000000 19.000000 20.000000
+Data path /entry/r8_data
    r8_data(6)
 .000000 2.000000 3.000000 4.000000
 …
          target : /entry/r8_data
    Subgroup: sample(NXsample)
+Group path /link/sample
 Link check OK
 NXopenpath checks OK
 …
 [[NXinquirefile found: NXtest.hdf
 Number of global attributes: 4
    NeXus_version = 4.2.0
+   NeXus_version = 4.2.1
    file_name = NXtest.hdf
 Number of group attributes: 2
+NXentry path /entry
    hugo = namenlos
    cucumber = passion
 Group: entry(NXentry) contains 9 items
+Data path /entry/ch_data
    ch_data(4) = NeXus ><}&{'\&" Data
+Data path /entry/c1_data
    c1_data(4) = abcdefghijklmnopqrst
+Data path /entry/i1_data
    i1_data(20) =  1 2 3 4
+Data path /entry/i2_data
    i2_data(22) =  1000 2000 3000 4000
+Data path /entry/i4_data
    i4_data(24) =  1000000 2000000 3000000 4000000
+Data path /entry/r4_data
    r4_data(5)
 .000000 2.000000 3.000000 4.000000
 …
 .000000 14.000000 15.000000 16.000000
 .000000 18.000000 19.000000 20.000000
+Data path /entry/r8_data
    r8_data(6)
 .000000 2.000000 3.000000 4.000000
 …
    Subgroup: data(NXdata)
    Subgroup: sample(NXsample)
+Group path /link/sample
 Link check OK
 NXopenpath checks OK
 …
 [[NXinquirefile found: NXtest.h5
 Number of global attributes: 4
    NeXus_version = 4.2.0
+   NeXus_version = 4.2.1
    file_name = NXtest.h5
 Number of group attributes: 2
+NXentry path /entry
    hugo = namenlos
    cucumber = passion
 Group: entry(NXentry) contains 10 items
+Data path /entry/c1_data
    c1_data(4) = abcdefghijklmnopqrst
+Data path /entry/ch_data
    ch_data(4) = NeXus ><}&{'\&" Data
    Subgroup: data(NXdata)
+Data path /entry/grosse_zahl
    grosse_zahl(26) =  12 555555555555 23 777777777777
+Data path /entry/i1_data
    i1_data(20) =  1 2 3 4
+Data path /entry/i2_data
    i2_data(22) =  1000 2000 3000 4000
+Data path /entry/i4_data
    i4_data(24) =  1000000 2000000 3000000 4000000
+Data path /entry/r4_data
    r4_data(5)
 .000000 2.000000 3.000000 4.000000
 …
 .000000 14.000000 15.000000 16.000000
 .000000 18.000000 19.000000 20.000000
+Data path /entry/r8_data
    r8_data(6)
 .000000 2.000000 3.000000 4.000000
 …
          target : /entry/r8_data
    Subgroup: sample(NXsample)
+Group path /link/sample
 Link check OK
 NXopenpath checks OK
 …
 [[NXinquirefile found: NXtest.xml
 Number of global attributes: 7
    NeXus_version = 4.2.0
+   NeXus_version = 4.2.1
    file_name = NXtest.xml
    xmlns = http://definition.nexusformat.org/schema/3.0
+   xmlns = http://definition.nexusformat.org/schema/3.1
    xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance
    xsi:schemaLocation = http://definition.nexusformat.org/schema/3.0 http://definition.nexusformat.org/schema/3.0/BASE.xsd
+   xsi:schemaLocation = http://definition.nexusformat.org/schema/3.1 http://definition.nexusformat.org/schema/3.1/BASE.xsd
 Number of group attributes: 2
+NXentry path /entry
    hugo = namenlos
    cucumber = passion
 Group: entry(NXentry) contains 10 items
+Data path /entry/ch_data
    ch_data(4) = NeXus ><}&{'\&" Data
+Data path /entry/c1_data
    c1_data(4) = abcdefghijklmnopqrst
+Data path /entry/i1_data
    i1_data(20) =  1 2 3 4
+Data path /entry/i2_data
    i2_data(22) =  1000 2000 3000 4000
+Data path /entry/i4_data
    i4_data(24) =  1000000 2000000 3000000 4000000
+Data path /entry/r4_data
    r4_data(5)
 .000000 2.000000 3.000000 4.000000
 …
 .000000 14.000000 15.000000 16.000000
 .000000 18.000000 19.000000 20.000000
+Data path /entry/r8_data
    r8_data(6)
 .000000 2.000000 3.000000 4.000000
 …
          r4_attribute : 3.141593
          target : /entry/r8_data
+Data path /entry/grosse_zahl
    grosse_zahl(26) =  12 555555555555 23 777777777777
    Subgroup: data(NXdata)
    Subgroup: sample(NXsample)
+Group path /link/sample
 Link check OK
 NXopenpath checks OK
 …
 [[NXinquirefile found: NXtest.xml
 Number of global attributes: 7
    NeXus_version = 4.2.0
+   NeXus_version = 4.2.1
    file_name = NXtest.xml
    xmlns = http://definition.nexusformat.org/schema/3.0
+   xmlns = http://definition.nexusformat.org/schema/3.1
    xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance
    xsi:schemaLocation = http://definition.nexusformat.org/schema/3.0 http://definition.nexusformat.org/schema/3.0/BASE.xsd
+   xsi:schemaLocation = http://definition.nexusformat.org/schema/3.1 http://definition.nexusformat.org/schema/3.1/BASE.xsd
 Number of group attributes: 2
+NXentry path /entry
    hugo = namenlos
    cucumber = passion
 Group: entry(NXentry) contains 10 items
+Data path /entry/ch_data
    ch_data(4) = NeXus ><}&{'\&" Data
+Data path /entry/c1_data
    c1_data(4) = abcdefghijklmnopqrst
+Data path /entry/i1_data
    i1_data(20) =  1 2 3 4
+Data path /entry/i2_data
    i2_data(22) =  1000 2000 3000 4000
+Data path /entry/i4_data
    i4_data(24) =  1000000 2000000 3000000 4000000
+Data path /entry/r4_data
    r4_data(5)
 .000000 2.000000 3.000000 4.000000
 …
 .000000 14.000000 15.000000 16.000000
 .000000 18.000000 19.000000 20.000000
+Data path /entry/r8_data
    r8_data(6)
 .000000 2.000000 3.000000 4.000000
 …
          r4_attribute : 3.141593
          target : /entry/r8_data
+Data path /entry/grosse_zahl
    grosse_zahl(26) =  12 555555555555 23 777777777777
    Subgroup: data(NXdata)
    Subgroup: sample(NXsample)
+Group path /link/sample
 Link check OK
 NXopenpath checks OK
 …
 [[NXinquirefile found: NXtest-table.xml
 Number of global attributes: 7
    NeXus_version = 4.2.0
+   NeXus_version = 4.2.1
    file_name = NXtest-table.xml
    xmlns = http://definition.nexusformat.org/schema/3.0
+   xmlns = http://definition.nexusformat.org/schema/3.1
    xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance
    xsi:schemaLocation = http://definition.nexusformat.org/schema/3.0 http://definition.nexusformat.org/schema/3.0/BASE.xsd
+   xsi:schemaLocation = http://definition.nexusformat.org/schema/3.1 http://definition.nexusformat.org/schema/3.1/BASE.xsd
 Number of group attributes: 2
+NXentry path /entry
    hugo = namenlos
    cucumber = passion
 Group: entry(NXentry) contains 10 items
+Data path /entry/ch_data
    ch_data(4) = NeXus ><}&{'\&" Data
+Data path /entry/c1_data
    c1_data(4) = abcdefghijklmnopqrst
+Data path /entry/i1_data
    i1_data(20) =  1 2 3 4
+Data path /entry/i2_data
    i2_data(22) =  1000 2000 3000 4000
+Data path /entry/i4_data
    i4_data(24) =  1000000 2000000 3000000 4000000
+Data path /entry/grosse_zahl
    grosse_zahl(26) =  12 555555555555 23 777777777777
+Data path /entry/r4_data
    r4_data(5)
 .000000 2.000000 3.000000 4.000000
 …
 .000000 14.000000 15.000000 16.000000
 .000000 18.000000 19.000000 20.000000
+Data path /entry/r8_data
    r8_data(6)
 .000000 2.000000 3.000000 4.000000
 …
    Subgroup: data(NXdata)
    Subgroup: sample(NXsample)
+Group path /link/sample
 Link check OK
 NXopenpath checks OK
 …
 AT_CHECK([ $HAVE_F77 && $HAVE_HDF4 && $SETUP_TEST && napif_test-hdf4 | sed -e 's/\r$//' ], [],
 [[ Number of global attributes:  4
     NeXus_version = 4.2.0
+    NeXus_version = 4.2.1
     file_name = NXtest.nxs
  Group: entry(NXentry) contains  8 items
+ Path = /entry/ch_data
     ch_data( 4)
     Values : NeXus data
+ Path = /entry/i1_data
     i1_data(20)
     Values :   1  2  3  4
+ Path = /entry/i2_data
     i2_data(22)
     Values :   1000  2000  3000  4000
+ Path = /entry/i4_data
     i4_data(24)
     Values :      1000000     2000000     3000000     4000000
+ Path = /entry/r4_data
     r4_data( 5)
     Values :    1.00   2.00   3.00   4.00
 …
            :   13.00  14.00  15.00  16.00
            :   17.00  18.00  19.00  20.00
+ Path = /entry/r8_data
     r8_data( 6)
     Values :    1.00   2.00   3.00   4.00
 …
 AT_CHECK([ $HAVE_F77 && $HAVE_HDF5 && $SETUP_TEST && napif_test-hdf5 | sed -e 's/\r$//' ], [],
 [[ Number of global attributes:  4
     NeXus_version = 4.2.0
+    NeXus_version = 4.2.1
     file_name = NXtest.nxs
  Group: entry(NXentry) contains  8 items
+ Path = /entry/ch_data
     ch_data( 4)
     Values : NeXus data
     Subgroup: data(NXdata)
+ Path = /entry/i1_data
     i1_data(20)
     Values :   1  2  3  4
+ Path = /entry/i2_data
     i2_data(22)
     Values :   1000  2000  3000  4000
+ Path = /entry/i4_data
     i4_data(24)
     Values :      1000000     2000000     3000000     4000000
+ Path = /entry/r4_data
     r4_data( 5)
     Values :    1.00   2.00   3.00   4.00
 …
            :   13.00  14.00  15.00  16.00
            :   17.00  18.00  19.00  20.00
+ Path = /entry/r8_data
     r8_data( 6)
     Values :    1.00   2.00   3.00   4.00
 …
 [[Writing character data
 Number of global attributes:        4
    NeXus_version = 4.2.0
+   NeXus_version = 4.2.1
    file_name = NXtest.nxs
 Group: entry(NXentry) contains        8 items
 …
 [[NXinquirefile found: napi_test_cpp.hdf
 Number of global attributes: 4
    NeXus_version = 4.2.0
+   NeXus_version = 4.2.1
    file_name = napi_test_cpp.hdf
 Number of group attributes: 2
 …
 Group contains 9 items
    c1_data[5,4] = 2d character array
+   Path = /entry/c1_data
    ch_data[10] = NeXus_data
+   Path = /entry/ch_data
    data:NXdata
    i1_data[4] = [,,,]
+   Path = /entry/i1_data
    i2_data[4] = [1000,2000,3000,4000]
+   Path = /entry/i2_data
    i4_data[4] = [1000000,2000000,3000000,4000000]
+   Path = /entry/i4_data
    r4_data[5,4] = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]
+   Path = /entry/r4_data
    r8_data[5,4] = [20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39]
+   Path = /entry/r8_data
    sample:NXsample
 Link check OK
 …
 [[NXinquirefile found: napi_test_cpp.h5
 Number of global attributes: 4
    NeXus_version = 4.2.0
+   NeXus_version = 4.2.1
    file_name = napi_test_cpp.h5
 Number of group attributes: 2
 …
 Group contains 10 items
    c1_data[5,4] = 2d character array
+   Path = /entry/c1_data
    ch_data[10] = NeXus_data
+   Path = /entry/ch_data
    data:NXdata
    grosszahl[4] = [12,555555555555,23,777777777777]
+   Path = /entry/grosszahl
    i1_data[4] = [,,,]
+   Path = /entry/i1_data
    i2_data[4] = [1000,2000,3000,4000]
+   Path = /entry/i2_data
    i4_data[4] = [1000000,2000000,3000000,4000000]
+   Path = /entry/i4_data
    r4_data[5,4] = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]
+   Path = /entry/r4_data
    r8_data[5,4] = [20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39]
+   Path = /entry/r8_data
    sample:NXsample
 Link check OK
 …
 [[NXinquirefile found: napi_test_cpp.xml
 Number of global attributes: 7
    NeXus_version = 4.2.0
+   NeXus_version = 4.2.1
    file_name = napi_test_cpp.xml
    xmlns = http://definition.nexusformat.org/schema/3.0
+   xmlns = http://definition.nexusformat.org/schema/3.1
    xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance
    xsi:schemaLocation = http://definition.nexusformat.org/schema/3.0 http://definition.nexusformat.org/schema/3.0/BASE.xsd
+   xsi:schemaLocation = http://definition.nexusformat.org/schema/3.1 http://definition.nexusformat.org/schema/3.1/BASE.xsd
 Number of group attributes: 2
    hugo = namenlos
 …
 Group contains 10 items
    c1_data[5,4] = 2d character array
+   Path = /entry/c1_data
    ch_data[10] = NeXus_data
+   Path = /entry/ch_data
    data:NXdata
    grosszahl[4] = [12,555555555555,23,777777777777]
+   Path = /entry/grosszahl
    i1_data[4] = [,,,]
+   Path = /entry/i1_data
    i2_data[4] = [1000,2000,3000,4000]
+   Path = /entry/i2_data
    i4_data[4] = [1000000,2000000,3000000,4000000]
+   Path = /entry/i4_data
    r4_data[5,4] = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]
+   Path = /entry/r4_data
    r8_data[5,4] = [20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39]
+   Path = /entry/r8_data
    sample:NXsample
 Link check OK
 …
 attribute name: NeXus_version
 attribute value: 4.2.0
+attribute value: 4.2.1
 NXgetnextattr status:        1
 …
 attribute name: NeXus_version
 attribute value: 4.2.0
+attribute value: 4.2.1
 NXgetnextattr status:        1
 …
 attribute name: NeXus_version
 attribute value: 4.2.0
+attribute value: 4.2.1
 NXgetnextattr status:        1
 …
 attribute name: xmlns
 attribute value: http://definition.nexusformat.org/schema/3.0
+attribute value: http://definition.nexusformat.org/schema/3.1
 NXgetnextattr status:        1
 …
 attribute name: xsi:schemaLocation
 attribute value: http://definition.nexusformat.org/schema/3.0 http://definition.nexusformat.org/schema/3.0/BASE.xsd
+attribute value: http://definition.nexusformat.org/schema/3.1 http://definition.nexusformat.org/schema/3.0/BASE.xsd
 NXgetnextattr status:        1
 …
 AT_BANNER([[Testing NXbrowse Tool.]])
 AT_SETUP([Checking HDF4 test file])
 AT_CHECK([$HAVE_HDF4 && nxbrowse NXtest.hdf  < ${abs_srcdir}/nxbrowse.txt | grep -v 'HDF_version = ' | grep -v 'file_time = ' | sed -e 's/\r$//' | sed -e 's/[ ]*$//' ],[],
 [[NXBrowse 4.2.0 Copyright (C) 2000 R. Osborn, M. Koennecke, P. Klosowski
     NeXus_version = 4.2.0
+AT_CHECK([$HAVE_HDF4 && env NO_READLINE=1 nxbrowse NXtest.hdf  < ${abs_srcdir}/nxbrowse.txt | grep -v 'HDF_version = ' | grep -v 'file_time = ' | sed -e 's/\r$//' | sed -e 's/[ ]*$//' ],[],
+[[NXBrowse 4.2.1 Copyright (C) 2009 NeXus Data Format
+    NeXus_version = 4.2.1
     file_name = NXtest.hdf
 NX>   NX Group : entry (NXentry)
 …
 AT_CLEANUP
 AT_SETUP([Checking HDF5 test file])
 AT_CHECK([$HAVE_HDF5 && nxbrowse NXtest.h5  < ${abs_srcdir}/nxbrowse.txt | grep -v 'HDF5_Version = ' | grep -v 'file_time = ' | sed -e 's/\r$//' | sed -e 's/[ ]*$//' ],[],
 [[NXBrowse 4.2.0 Copyright (C) 2000 R. Osborn, M. Koennecke, P. Klosowski
     NeXus_version = 4.2.0
+AT_CHECK([$HAVE_HDF5 && env NO_READLINE=1 nxbrowse NXtest.h5  < ${abs_srcdir}/nxbrowse.txt | grep -v 'HDF5_Version = ' | grep -v 'file_time = ' | sed -e 's/\r$//' | sed -e 's/[ ]*$//' ],[],
+[[NXBrowse 4.2.1 Copyright (C) 2009 NeXus Data Format
+    NeXus_version = 4.2.1
     file_name = NXtest.h5
 NX>   NX Group : entry (NXentry)
 …
 AT_CLEANUP
 AT_SETUP([Checking XML test file])
 AT_CHECK([$HAVE_XML && nxbrowse NXtest.xml  < ${abs_srcdir}/nxbrowse.txt | grep -v 'file_time = ' | grep -v 'XML_version = ' | sed -e 's/\r$//' | sed -e 's/[ ]*$//' ],[],
 [[NXBrowse 4.2.0 Copyright (C) 2000 R. Osborn, M. Koennecke, P. Klosowski
     NeXus_version = 4.2.0
+AT_CHECK([$HAVE_XML && env NO_READLINE=1 nxbrowse NXtest.xml  < ${abs_srcdir}/nxbrowse.txt | grep -v 'file_time = ' | grep -v 'XML_version = ' | sed -e 's/\r$//' | sed -e 's/[ ]*$//' ],[],
+[[NXBrowse 4.2.1 Copyright (C) 2009 NeXus Data Format
+    NeXus_version = 4.2.1
     file_name = NXtest.xml
     xmlns = http://definition.nexusformat.org/schema/3.0
+    xmlns = http://definition.nexusformat.org/schema/3.1
     xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance
     xsi:schemaLocation = http://definition.nexusformat.org/schema/3.0 http://definition.nexusformat.org/schema/3.0/BASE.xsd
+    xsi:schemaLocation = http://definition.nexusformat.org/schema/3.1 http://definition.nexusformat.org/schema/3.1/BASE.xsd
 NX>   NX Group : entry (NXentry)
              entry attribute: hugo = namenlos
 …
 ]])
 AT_CLEANUP
-AT_BANNER([[Testing validating files with the nxvalidate tool.]])
-AT_SETUP([Checking HDF4 test file via web (wget)])
-AT_CHECK([$HAVE_HDF4 && $HAVE_WGET && $SETUP_TEST && napi_test-hdf4 -q && nxvalidate -q -w NXtest.hdf | sed -e 's/\r$//' ],[],
-[[]])
-AT_CLEANUP
-AT_SETUP([Checking HDF5 test file via web (wget)])
-AT_CHECK([$HAVE_HDF4 && $HAVE_WGET && $SETUP_TEST && napi_test-hdf5 -q && nxvalidate -q -w NXtest.h5 | sed -e 's/\r$//' ],[],
-[[]])
-AT_CLEANUP
-AT_SETUP([Checking XML test file via web (wget)])
-AT_CHECK([$HAVE_HDF4 && $HAVE_WGET && $SETUP_TEST && napi_test-xml -q && nxvalidate -q -w NXtest.xml | sed -e 's/\r$//' ],[],
-[[]])
-AT_CLEANUP

tags/4.2.1/test/leak_test2.cxx

r1896	r1896
1	1	#include <sstream>
2	2	#include <cstdlib>
	3	#include <cstdio>
3	4	#include <napi.h>
4	5	#include <unistd.h>

tags/4.2.1/nexus_spec.in

r1896	r1896
71	71	%{_datadir}/*
72	72	%{_includedir}/*
	73	/usr/lib/python*/site-packages/nxs
73	74	#%files devel
74	75	#%{_libdir}/*.a

tags/4.2.1/include

Property svn:mergeinfo set to
/trunk/include merged eligible

tags/4.2.1/include/Makefile.am

r1896	r1896
9	9	include_HEADERS = napi.h napiu.h
10	10
11		noinst_HEADERS = napi4.h napi5.h nxxml.h napiconfig.h
	11	noinst_HEADERS = napi4.h napi5.h nxxml.h napiconfig.h nxconfig_vms.h

tags/4.2.1/include/napi.h

                       r1896
 /* NeXus HDF45 */
 #define NEXUS_VERSION   "4.2.0"                /* major.minor.patch */
+#define NEXUS_VERSION   "4.2.1"                /* major.minor.patch */
 #define CONSTCHAR       const char
 …
 #    define NXopengroup         MANGLE(nxiopengroup)
 #    define NXopenpath          MANGLE(nxiopenpath)
+#    define NXgetpath           MANGLE(nxigetpath)
 #    define NXopengrouppath     MANGLE(nxiopengrouppath)
 #    define NXclosegroup        MANGLE(nxiclosegroup)
 …
 #    define NXisexternalgroup   MANGLE(nxiisexternalgroup)
 #    define NXlinkexternal      MANGLE(nxilinkexternal)
+#    define NXgetversion        MANGLE(nxigetversion)
 /*
 …
 #    define NXfcompress         MANGLE(nxifcompress)
 #    define NXfputattr          MANGLE(nxifputattr)
+#    define NXfgetpath          MANGLE(nxifgetpath)
 /*
 …
    */
 extern  NXstatus  NXopengrouppath (NXhandle handle, CONSTCHAR *path);
+  /**
+   * Retrieve the current path in the NeXus file
+   * \param handle a NeXus file handle
+   * \param path A buffer to copy the path too
+   * \parm  pathlen The maximum number of characters to copy into path
+   * \return NX_OK or NX_ERROR
+   */
+extern NXstatus NXgetpath(NXhandle handle, char *path, int pathlen);
   /**
 …
   /**
+   * Utility function to return NeXus version
+   * \return pointer to string in static storage. Version in
+   * same format as NEXUS_VERSION string in napi.h i.e. "major.minor.patch"
+   * \ingroup c_metadata
+   */
+extern  const char* NXgetversion();
+  /**
    * Utility function to release the memory for data.
    * \param data A pointer to a pointer to free.
 …
   /**
+   * Set an error function.
+   * \param pData A pointer to a user defined data structure which be passed opaquely to
+   * Set a global error function.
+   * Not threadsafe.
+   * \param pData A pointer to a user defined data structure which be passed to
    * the error display function.
    * \param newErr The new error display function.
 …
   /**
+   * Set an error function for the current thread.
+   * When used this overrides anything set in NXMSetError (for the current thread).
+   * Use this method in threaded applications.
+   * \param pData A pointer to a user defined data structure which be passed to
+   * the error display function.
+   * \param newErr The new error display function.
+   */
+extern  void  NXMSetTError(void *pData, ErrFunc newErr);
+  /**
    * Retrieve the current error display function
    * \return The current erro display function.
+   * \return The current error display function.
    */
 extern ErrFunc NXMGetError();
 …
 extern void (*NXIReportError)(void *pData,char *text);
+extern void NXIReportError(void *pData,char *text);
 extern void *NXpData;
 extern char *NXIformatNeXusTime();
 …
   extern NXstatus  NXfopen(char * filename, NXaccess* am,
                                         NexusFunction* pHandle);
   extern NXstatus  NXfclose (NexusFunction* pHandle);
+                                        NXhandle pHandle);
+  extern NXstatus  NXfclose (NXhandle pHandle);
   extern NXstatus  NXfputattr(NXhandle fid, char *name, void *data,
                                    int *pDatalen, int *pIType);
 …
   extern NXstatus  NXfmakedata(NXhandle fid, char *name, int *pDatatype,
                 int *pRank, int dimensions[]);
   extern NXstatus  NXfflush(NexusFunction* pHandle);
+  extern NXstatus  NXfflush(NXhandle pHandle);
+  extern NXstatus  NXfgetpath(NXhandle fid, char *path, int *pathlen);
 #ifdef __cplusplus
+}
 #endif /* __cplusplus */
+/**
+ * Freddie Akeroyd 11/8/2009
+ * Add NeXus schema support - this uses BASE.xsd as the initial file
+ */
+#define NEXUS_SCHEMA_VERSION    "3.1"   /**< version of NeXus definition schema */
+#define NEXUS_SCHEMA_ROOT       "http://definition.nexusformat.org/schema/"     /**< XML schema namespace specified by xmlns */
+#define NEXUS_SCHEMA_NAMESPACE  NEXUS_SCHEMA_ROOT NEXUS_SCHEMA_VERSION  /**< XML schema namespace specified by xmlns */
+#define NEXUS_SCHEMA_BASE       "BASE"
+#define NEXUS_SCHEMA_FILE       NEXUS_SCHEMA_BASE ".xsd" /**< default schema file for namespace */
+#define NEXUS_SCHEMA_URL        NEXUS_SCHEMA_NAMESPACE "/" NEXUS_SCHEMA_FILE /**< location of default schema file for namespace */
 #endif /*NEXUSAPI*/

tags/4.2.1/include/napiconfig.h

                       r1896
 #endif /* _WIN32 */
+#ifdef __VMS
+#include <nxconfig_vms.h>
+#else
 #include <nxconfig.h>
+#endif /* __VMS */
 /*
 …
 #if HAVE_STDINT_H
 #include <stdint.h>
+#elif HAVE_INTTYPES_H
+#include <inttypes.h>
 #endif /* HAVE_STDINT_H */

Context Navigation

Changes from tags/4.2.0 at r1896 to tags/4.2.1 at r1896

Legend:

Download in other formats: