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


Ignore:
Location:
tags
Files:
38 added
1 deleted
68 edited

Legend:

Unmodified
Added
Removed
  • tags/4.2.1/Makefile.am

    r1924 r1924  
    22#  NeXus - Neutron & X-ray Common Data Format 
    33 
    4 #  $Id$ 
    5 # 
    64#  Top level Makefile for coordinating NeXus build 
    75 
     
    2321#  MA  02111-1307  USA 
    2422#              
    25 #  For further information, see <http://www.neutron.anl.gov/NeXus/> 
     23#  For further information, see <http://www.nexusformat.org> 
    2624# 
    2725#  @configure_input@ 
     
    3533CONTRIB=contrib 
    3634endif 
    37 SUBDIRS=include src bindings applications test scripts examples doc $(CONTRIB) 
     35SUBDIRS=include src bindings applications test scripts examples doc macosx_install_kit $(CONTRIB) 
    3836 
    3937EXTRA_DIST=build_rules.am nexus_spec.in nexus.spec autoversion.sh \ 
    4038                build_rpm.in README.cygwin README.WIN32 README.macosx \ 
    41                 README.MinGW make_mingw_links SConstruct nexus_scons_utils.py 
     39                README.MinGW make_mingw_links SConstruct nexus_scons_utils.py \ 
     40                configure_mingw_kit 
    4241 
    4342# Add any flags here that you want passed to configure when you do  
    4443# a "make distcheck" 
    4544# DISTCHECK_CONFIGURE_FLAGS=--without-java 
     45MAINTAINERCLEANFILES = \ 
     46 ChangeLog \ 
     47 INSTALL \ 
     48 aclocal.m4 \ 
     49 config \ 
     50 configure \ 
     51 doc/tech_ref/NeXus_definitions.pdf \ 
     52 doc/tech_ref/NeXus_definitions.txt \ 
     53 include/nxconfig_h.in \ 
     54 `find "$(srcdir)" -type f -name Makefile.in -print` 
  • tags/4.2.1/NEWS

    r1924 r1924  
     1 
     2For the latest information see  
     3 
     4    http://www.nexusformat.org/Nexus_42_Release_Notes 
     5 
     6Version 4.2.1 
     7============= 
     8 
     9The following new featues have been added:  
     10 
     11* NXbrowse now has readline support (i.e. previous command line recall and  
     12  TAB completion of entry names)  
     13* new API functions NXgetpath() and NXgetversion() added  
     14* NXgetnextentry() now uses less stack space  
     15 
    116Version 4.2.0 
    217============= 
    3  
    4 For the latest information see  
    5  
    6     http://www.nexusformat.org/Nexus_42_Release_Notes 
    718 
    819==System Requirements== 
  • tags/4.2.1/acinclude.m4

    r1924 r1924  
    156156    fi 
    157157  ]) 
     158 
     159AC_DEFUN([AC_CHECK_PYTHON_MODULE], 
     160[ 
     161    if test -z "$PYTHON"; then PYTHON="python"; fi 
     162    AC_MSG_CHECKING(for python module $1) 
     163    $PYTHON -c "import $1" 2>/dev/null 
     164    if test $? -eq 0; then 
     165        eval PYTHON_$1=1 
     166        eval PYTHON_$1_found="yes" 
     167        AC_MSG_RESULT(found) 
     168    else 
     169        eval PYTHON_$1=0 
     170        eval PYTHON_$1_found="no" 
     171        AC_MSG_RESULT(not found) 
     172    fi 
     173    AC_SUBST(PYTHON_$1) 
     174]) 
  • tags/4.2.1/applications/NXbrowse.c

    r1924 r1924  
    2626           USA 
    2727 
    28  For further information, see <http://www.neutron.anl.gov/NeXus/> 
     28 For further information, see <http://www.nexusformat.org> 
    2929 
    3030 $Id$ 
     
    3333#include <stdio.h> 
    3434#include <string.h> 
     35#include <stdlib.h> 
    3536#include "napi.h" 
    3637#include "napiconfig.h" 
     38static char* my_readline(const char* prompt) 
     39{ 
     40    char inputText[256]; 
     41    char* stringPtr; 
     42    fprintf(stdout, "%s", prompt); 
     43    if (fgets(inputText, sizeof(inputText), stdin) == NULL) 
     44    { 
     45        return NULL; 
     46    } 
     47    if ((stringPtr = strchr(inputText, '\n')) != NULL)  
     48    { 
     49        *stringPtr = '\0'; 
     50    } 
     51    return strdup(inputText); 
     52} 
     53#if HAVE_LIBREADLINE 
     54#include <readline/readline.h> 
     55#include <readline/history.h> 
     56#ifndef HAVE_RL_COMPLETION_MATCHES 
     57#define rl_completion_matches(a,b) completion_matches(a,b) 
     58#endif /* ifndef HAVE_RL_COMPLETION_MATCHES */ 
     59#else 
     60#define rl_completion_matches(a,b) NULL 
     61#define rl_outstream stdout 
     62#define readline my_readline 
     63#endif 
    3764 
    3865#define StrEq(s1, s2) (strcmp((s1), (s2)) == 0) 
     
    5784static char nxFile[256]; 
    5885 
     86static NXhandle the_fileId; 
     87 
     88/*  
     89 * Freddie Akeroyd 18/10/2009  
     90 * 
     91 * Add in support for readline and completion (nxbrowse_complete) of commands 
     92 * (command_generator) and on data/group names (field_generator) 
     93 * a / character is appended to group names for display, but stripped off 
     94 * by the cd command (we may want to remove this and use openpath() later) 
     95 * 
     96 */ 
     97typedef struct { 
     98    const char* name; 
     99    const char* doc; 
     100} COMMAND; 
     101 
     102COMMAND commands[] = { 
     103    { "cd", "Move into to a group" }, 
     104    { "close", "Move out of a group" }, 
     105    { "dir", "" }, 
     106    { "read", "" }, 
     107    { "open", "" }, 
     108    { "help", "" }, 
     109    { "info", "" }, 
     110    { "exit", "" }, 
     111    { "dump", "" }, 
     112    { "bytesaschar", "" }, 
     113    { NULL, NULL } 
     114}; 
     115 
     116static char* command_generator(const char* text, int state) 
     117{ 
     118    static int len, list_index; 
     119    const char* name; 
     120    if (!state) 
     121    { 
     122        list_index = 0; 
     123        len = strlen(text); 
     124    }  
     125    while( (name = commands[list_index].name) != NULL ) 
     126    { 
     127        ++list_index; 
     128        if (strncasecmp(name, text, len) == 0) 
     129        { 
     130            return strdup(name); 
     131        } 
     132    } 
     133    return NULL; 
     134} 
     135 
     136struct name_item; 
     137 
     138struct name_item 
     139{ 
     140    char* name; 
     141    struct name_item* next; 
     142}; 
     143     
     144static char* field_generator(const char* text, int state) 
     145{ 
     146    static int len; 
     147    struct name_item *item, *t_item; 
     148    static struct name_item *names = NULL, *last_item = NULL; 
     149    char* res; 
     150    int status, dataType; 
     151    NXname name, nxclass; 
     152    if (!state) 
     153    { 
     154        item = names; 
     155        while(item != NULL) 
     156        { 
     157            if (item->name != NULL) 
     158            { 
     159                free(item->name); 
     160                item->name = NULL; 
     161            } 
     162            t_item = item; 
     163            item = item->next; 
     164            t_item->next = NULL; 
     165            free(t_item); 
     166        } 
     167        last_item = names = NULL; 
     168        len = strlen(text); 
     169        if (NXinitgroupdir (the_fileId) != NX_OK) 
     170        { 
     171            return NULL; 
     172        } 
     173        do  
     174        { 
     175           status = NXgetnextentry (the_fileId, name, nxclass, &dataType); 
     176           if (status == NX_ERROR) break; 
     177           if (status == NX_OK)  
     178           { 
     179              if (strncmp(nxclass,"CDF",3) == 0){  
     180                  ; 
     181              } 
     182              else if (strncmp(name, text, len) == 0) 
     183              { 
     184                  item = (struct name_item*)malloc(sizeof(struct name_item)); 
     185                  item->name = strdup(name); 
     186                  if (strcmp(nxclass,"SDS") != 0){  
     187                     strcat(item->name, "/"); 
     188                  } 
     189                  item->next = NULL; 
     190                  if (last_item == NULL) 
     191                  { 
     192                    names = item; 
     193                  } 
     194                  else 
     195                  { 
     196                    last_item->next = item; 
     197                  } 
     198                  last_item = item; 
     199              } 
     200           }  
     201        } while (status == NX_OK); 
     202        last_item = names; 
     203    } 
     204    if (last_item != NULL) 
     205    { 
     206       res = strdup(last_item->name); 
     207       last_item = last_item->next; 
     208    } 
     209    else 
     210    { 
     211        res = NULL; 
     212    } 
     213    return res; 
     214} 
     215 
     216static char** nxbrowse_complete(const char* text, int start, int end) 
     217{ 
     218    char** matches = NULL; 
     219    static char line[512]; 
     220    strncpy(line, text+start, end-start); 
     221    line[end-start] = '\0'; 
     222    if (start == 0)  
     223    { 
     224        matches = rl_completion_matches(text, command_generator); 
     225    } 
     226    else 
     227    { 
     228        matches = rl_completion_matches(text, field_generator); 
     229    } 
     230    return matches; 
     231} 
     232 
     233 
    59234int main(int argc, char *argv[]) 
    60235{ 
    61    NXhandle fileId; 
    62    char fileName[80], inputText[255], path[80], *command, *dimensions, *stringPtr; 
     236   char fileName[800], path[800], *command, *dimensions, *stringPtr; 
     237   char prompt[512]; 
     238   char *inputText; 
    63239   NXname groupName, dataName; 
    64240   int status, groupLevel = 0, i; 
    65241 
    66    printf ("NXBrowse %s Copyright (C) 2000 R. Osborn, M. Koennecke, P. Klosowski\n", NEXUS_VERSION); 
     242#if HAVE_LIBREADLINE 
     243   rl_readline_name = "NXbrowse"; 
     244   rl_attempted_completion_function = nxbrowse_complete; 
     245#if READLINE_VERSION >= 0x500 
     246   rl_catch_signals = 0; 
     247#else 
     248#define rl_crlf() fprintf(rl_outstream, "\r\n"); 
     249#define rl_on_new_line() 1 
     250#endif 
     251   using_history(); 
     252#else 
     253#define rl_crlf() 
     254#define rl_on_new_line() 
     255#define add_history(a) 
     256#endif 
     257 
     258   printf ("NXBrowse %s Copyright (C) 2009 NeXus Data Format\n", NEXUS_VERSION); 
    67259 
    68260/* if there is a filename given on the command line use that, 
     
    80272  
    81273/* Open input file and output global attributes */ 
    82    if (NXopen (fileName, NXACC_READ, &fileId) != NX_OK) { 
     274   if (NXopen (fileName, NXACC_READ, &the_fileId) != NX_OK) { 
    83275      printf ("NX_ERROR: Can't open %s\n", fileName); 
    84276      return NX_ERROR; 
    85277   } 
    86    PrintAttributes (fileId); 
     278   PrintAttributes (the_fileId); 
    87279   iByteAsChar = 0; /* Display remaining NX_INT8 and NX_UINT8 variables as integers by default */ 
    88280/* Input commands until the EXIT command is given */ 
    89281   strcpy (path, "NX"); 
    90282   do { 
    91       printf ("%s> ", path); 
    92       if (fgets(inputText, sizeof(inputText), stdin) == NULL) 
     283      sprintf (prompt, "%s> ", path); 
     284      if (getenv("NO_READLINE") != NULL) 
    93285      { 
    94          return NX_OK; 
    95       } 
    96  
    97       if ((stringPtr = strchr(inputText, '\n')) != NULL)  
    98          *stringPtr = '\0'; 
     286          inputText = my_readline(prompt); 
     287      } 
     288      else 
     289      { 
     290          inputText = readline(prompt); 
     291      } 
     292      if (inputText == NULL) 
     293      { 
     294          inputText = strdup("EXIT"); 
     295      } 
     296      if (*inputText) 
     297      { 
     298          add_history(inputText); 
     299      } 
    99300      command = strtok(inputText," "); 
    100301      /* Check if a command has been given */ 
     
    104305      /* Command is to print a directory of the current group */ 
    105306      if (StrEq(command, "DIR") || StrEq(command, "LS")) { 
    106          status = NXBdir (fileId); 
     307         status = NXBdir (the_fileId); 
    107308      }     
    108309      /* Command is to open the specified group */ 
    109310      if (StrEq(command, "OPEN") || StrEq(command, "CD")) { 
    110          stringPtr = strtok(NULL, " ");  
     311         stringPtr = strtok(NULL, " /");  
    111312         if (stringPtr != NULL) { 
    112313            strcpy (groupName, stringPtr); 
    113             status = NXBopen (fileId, groupName); 
    114             /* Add the group to the prompt string */ 
    115             if (status == NX_OK) { 
    116                strcat (path, "/"); 
    117                strcat (path, groupName); 
    118                groupLevel++; 
    119             } 
     314                         if (StrEq(groupName, "..")) { 
     315                                 strcpy(command, "CLOSE"); 
     316                         } else { 
     317                                 status = NXBopen (the_fileId, groupName); 
     318                                 /* Add the group to the prompt string */ 
     319                                 if (status == NX_OK) { 
     320                                         strcat (path, "/"); 
     321                                         strcat (path, groupName); 
     322                                         groupLevel++; 
     323                                 } 
     324                         } 
    120325         } 
    121326         else { 
    122             printf ("NX_ERROR: Specify a group\n"); 
     327            fprintf (rl_outstream, "NX_ERROR: Specify a group\n"); 
    123328         } 
    124329      } 
     
    131336            if (stringPtr != NULL) { 
    132337               strcpy (fileName, stringPtr); 
    133                status = NXBdump (fileId, dataName, fileName); 
     338               status = NXBdump (the_fileId, dataName, fileName); 
    134339            } 
    135340            else { 
    136                printf ("NX_ERROR: Specify a dump file name \n"); 
     341               fprintf (rl_outstream, "NX_ERROR: Specify a dump file name \n"); 
    137342            } 
    138343         } 
    139344         else { 
    140             printf ("NX_ERROR: Specify a data item\n"); 
     345            fprintf (rl_outstream, "NX_ERROR: Specify a data item\n"); 
    141346         } 
    142347      } 
     
    147352            strcpy (dataName, stringPtr); 
    148353            dimensions = strtok(NULL, "[]"); 
    149             status = NXBread (fileId, dataName, dimensions); 
     354            status = NXBread (the_fileId, dataName, dimensions); 
    150355         } 
    151356         else { 
    152             printf ("NX_ERROR: Specify a data item\n"); 
     357            fprintf (rl_outstream, "NX_ERROR: Specify a data item\n"); 
    153358         } 
    154359      } 
     
    156361      if (StrEq(command, "CLOSE")) { 
    157362         if (groupLevel > 0) { 
    158             if (NXclosegroup (fileId) == NX_OK) { 
     363            if (NXclosegroup (the_fileId) == NX_OK) { 
    159364               /* Remove the group from the prompt string */ 
    160365               stringPtr = strrchr (path, '/'); /* position of last group delimiter */ 
     
    165370         } 
    166371         else { 
    167             printf ("NX_WARNING: Already at root level of file\n"); 
     372            fprintf (rl_outstream, "NX_WARNING: Already at root level of file\n"); 
    168373         } 
    169374      } 
     
    189394      /* Command is to exit the program */ 
    190395      if (StrEq(command, "EXIT") || StrEq(command, "QUIT")) { 
    191          for (i = groupLevel; i > 0; i--) NXclosegroup (fileId); 
    192          NXclose (&fileId); 
     396         for (i = groupLevel; i > 0; i--) NXclosegroup (the_fileId); 
     397         NXclose (&the_fileId); 
    193398         return NX_OK; 
    194399      } 
    195400      status = NX_OK; 
     401      free(inputText); 
    196402   } while (status == NX_OK); 
    197403   return NX_OK; 
  • tags/4.2.1/applications/NXdir/data_writer.cpp

    r1924 r1924  
    3434 
    3535#define NXDATA "NXdata" 
    36 #define ATTR   "ATTR" 
    3736 
    3837using std::string; 
  • tags/4.2.1/applications/NXdir/string_util.cpp

    r1924 r1924  
    282282 */ 
    283283static string float_to_str(double value){ 
    284   char temp[20]; 
    285   sprintf(temp,"%f",value); 
     284  char temp[40]; 
     285  snprintf(temp,40,"%f",value); 
    286286 
    287287  return string(temp); 
     
    292292 */ 
    293293extern string int_to_str(const long value){ 
    294   char temp[20]; 
    295   sprintf(temp,"%d",value); 
     294  char temp[40]; 
     295  snprintf(temp,40,"%d",value); 
    296296 
    297297  return string(temp); 
  • tags/4.2.1/applications/NXsummary/main.cpp

    r1924 r1924  
    3030#include <string> 
    3131#include <cstring> 
     32#include <cstdio> 
    3233#include <vector> 
    3334#include "data_util.hpp" 
  • tags/4.2.1/applications/NXsummary/tclap/MultiArg.h

    r1924 r1924  
    2626#include <string> 
    2727#include <vector> 
     28#include <cstdio> 
    2829 
    2930#include <tclap/Arg.h> 
  • tags/4.2.1/applications/NXsummary/tclap/ValueArg.h

    r1924 r1924  
    2626#include <string> 
    2727#include <vector> 
     28#include <cstdio> 
    2829 
    2930#include <tclap/Arg.h> 
  • tags/4.2.1/applications/NXtranslate/Makefile.am

    r1924 r1924  
    6868nxtranslate_LDFLAGS = -static @HDF4_LDFLAGS@ @HDF5_LDFLAGS@ @XML_LDFLAGS@ $(LDFLAGS) 
    6969 
    70 #EXTRA_DIST = CHANGES LICENSE README TODO 
     70EXTRA_DIST = $(srcdir)/*.xml $(srcdir)/*.nxt $(srcdir)/*.dat $(srcdir)/*.run 
    7171 
    7272include $(top_srcdir)/build_rules.am 
  • tags/4.2.1/applications/NXtranslate/opengenie/Makefile.am

    r1924 r1924  
    3939libnxgenie_la_LDFLAGS = -no-undefined -export-dynamic -module $(LDFLAGS) 
    4040 
    41 EXTRA_DIST = README 
     41EXTRA_DIST = README nxgenie.gcl 
    4242 
    4343include $(top_srcdir)/build_rules.am 
  • tags/4.2.1/applications/nxdiff

    r1924 r1924  
    2828 
    2929def getPercentDiff(left, right, nandiff=float("nan")): 
    30     diffs = 100. * numpy.fabs((left-right)/left) 
     30    # find the difference (absolute) 
     31    diffs = left-right 
     32    combine = numpy.fabs(left) + numpy.fabs(right) 
     33 
     34    # fix the denominator so there are not nans 
     35    try: 
     36        indices = (combine == 0) 
     37        left[indices] = 1. 
     38    except IndexError: 
     39        if combine == 0: 
     40            left = 1. 
     41 
     42    # do the percent part 
     43    diffs = 100. * numpy.fabs(diffs/left) 
    3144    try: 
    3245        diffs[0] 
  • tags/4.2.1/bindings

  • tags/4.2.1/bindings/cpp/Makefile.am

    r1924 r1924  
    3535LIBNEXUS=$(top_builddir)/src/libNeXus.la 
    3636lib_LTLIBRARIES=libNeXusCPP.la 
     37AM_LDFLAGS=-version-info $(NXLTVERSINFO) 
    3738 
    3839# nxincludedir=$(includedir)/nexus 
  • tags/4.2.1/bindings/cpp/NeXusFile.cpp

    r1924 r1924  
    4141  } 
    4242 
     43  template<> 
     44  NXDLL_EXPORT NXnumtype getType(char number) { 
     45    stringstream msg; 
     46    msg << "NeXus::getType() does not know type of \"char\" " << number; 
     47    throw Exception(msg.str()); 
     48  } 
     49 
    4350  // template specialisations for types we know  
    4451  template<> 
     
    9198    return UINT64; 
    9299  } 
     100 
    93101 
    94102} 
     
    225233    throw Exception(msg.str(), status); 
    226234  } 
     235} 
     236 
     237std::string File::getPath(){ 
     238  char cPath[1024]; 
     239 
     240  memset(cPath,0,1024*sizeof(char)); 
     241  NXstatus status = NXgetpath(this->m_file_id,cPath, 1024); 
     242  if (status != NX_OK) { 
     243    stringstream msg; 
     244    msg << "NXgetpath() failed"; 
     245    throw Exception(msg.str(), status); 
     246  } 
     247  return std::string(cPath); 
    227248} 
    228249 
  • tags/4.2.1/bindings/cpp/NeXusFile.hpp

    r1924 r1924  
    181181     */ 
    182182    void openGroupPath(const std::string& path); 
     183    /** 
     184     * Get the path into the current file 
     185     * \return A unix like path string pointing to the current  
     186     *         position in the file 
     187     */ 
     188    std::string  getPath(); 
    183189 
    184190    /** 
  • tags/4.2.1/bindings/f77/Makefile.am

    r1924 r1924  
    2929#==================================================================== 
    3030lib_LTLIBRARIES=libNeXus77.la 
     31AM_LDFLAGS=-version-info $(NXLTVERSINFO) 
    3132 
    3233libNeXus77_la_SOURCES=napif.f 
  • tags/4.2.1/bindings/f77/napif.f

    r1924 r1924  
    121121      CALL EXTRACT_STRING(IPATH, 256, PATH) 
    122122      NXOPENPATH = NXIOPENPATH(FILEID, IPATH) 
     123      END 
     124 
     125      INTEGER FUNCTION NXGETPATH(FILEID, PATH) 
     126      INTEGER FILEID(*),NXIGETPATH, NXIFGETPATH 
     127      CHARACTER*(*) PATH 
     128      INTEGER*1 IPATH(1024) 
     129      INTEGER PLEN 
     130      EXTERNAL NXIFGETPATH 
     131      PLEN = 1024 
     132      NXGETPATH = NXIFGETPATH(FILEID,IPATH,PLEN) 
     133      CALL REPLACE_STRING(PATH,IPATH) 
    123134      END 
    124135 
  • tags/4.2.1/bindings/f77/napif.inc

    r1924 r1924  
    3636C *** large enough to hold an NXhandle structure 
    3737      INTEGER NXHANDLESIZE 
    38       PARAMETER(NXHANDLESIZE=5120) 
     38C      PARAMETER(NXHANDLESIZE=5120) 
     39      PARAMETER(NXHANDLESIZE=9058) 
    3940C *** NXLINKSIZE is (at least) the size of an INTEGER*4 array that can hold 
    4041C *** an NXlink structure: we'll assume 64bit alignment of structure members for safety 
     
    7980     +       NXINITATTRDIR, NXFLUSH, NXCOMPMAKEDATA, NXOPENPATH, 
    8081     +       NXSETNUMBERFORMAT, NXOPENGROUPPATH, NXOPENSOURCEGROUP, 
    81      +       NXMAKENAMEDLINK 
     82     +       NXMAKENAMEDLINK, NXGETPATH 
    8283      LOGICAL NXSAMEID 
    8384      EXTERNAL NXOPEN, NXCLOSE, NXMAKEGROUP, NXOPENGROUP, NXCLOSEGROUP, 
     
    9192     +       NXOPENPATH,NXSETNUMBERFORMAT, NXOPENGROUPPATH, 
    9293     +       NXOPENSOURCEGROUP, NXINQUIREFILE, NXISEXTERNALGROUP,  
    93      +       NXLINKEXTERNAL, NXMAKENAMEDLINK 
     94     +       NXLINKEXTERNAL, NXMAKENAMEDLINK, NXGETPATH 
  • tags/4.2.1/bindings/f90/Makefile.am

    r1924 r1924  
    2929#==================================================================== 
    3030lib_LTLIBRARIES = libNeXus90.la 
     31AM_LDFLAGS=-version-info $(NXLTVERSINFO) 
    3132 
    3233libNeXus90_la_SOURCES = NXmodule.f90 NXUmodule.f90 
  • tags/4.2.1/bindings/idl/NeXusIDL-API.c

    r1924 r1924  
    217217 
    218218  return IDL_GettmpInt(status); 
     219} 
     220/*====================================================================== 
     221 * NXgetpath 
     222 * string = NXgetpath(file_id) 
     223 *======================================================================*/ 
     224static IDL_VPTR NXgetpath_this(int argc, IDL_VPTR *argv) 
     225{ 
     226  int fileid; 
     227  NXhandle hHandle; 
     228  int iHandle, status; 
     229  char path[1024]; 
     230 
     231  if (argc != 1) { 
     232        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "One argument expected"); 
     233        return IDL_StrToSTRING("One argument expected"); 
     234        } 
     235 
     236  IDL_ENSURE_SCALAR(argv[0]); 
     237 
     238  fileid = (int)IDL_LongScalar(argv[0]); 
     239 
     240  if(HHCheckIfHandleExists(fileid) == -1) { 
     241        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id"); 
     242        return IDL_StrToSTRING("ERROR: Unknown file ID"); 
     243        } 
     244 
     245  hHandle = HHGetPointer(fileid); 
     246  NXMSetError(NULL,idlError); 
     247 
     248  status = NXgetpath(hHandle,path,1024); 
     249  if(status == NX_ERROR){ 
     250        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError); 
     251        return IDL_StrToSTRING(nexusError); 
     252  } 
     253   return IDL_StrToSTRING(path); 
    219254} 
    220255 
     
    25492584    { NXsetnumberformat_this, "NXSETNUMBERFORMAT", 0, IDL_MAXPARAMS, 0, 0}, 
    25502585    { NXopenpath_this, "NXOPENPATH", 0, IDL_MAXPARAMS, 0, 0}, 
    2551         { NXopengrouppath_this, "NXOPENGROUPPATH", 0, IDL_MAXPARAMS, 0, 0}, 
     2586    { NXopengrouppath_this, "NXOPENGROUPPATH", 0, IDL_MAXPARAMS, 0, 0}, 
     2587    { NXgetpath_this, "NXGETPATH", 0, IDL_MAXPARAMS, 0, 0}, 
    25522588    { NXmakegroup_this, "NXMAKEGROUP", 0, IDL_MAXPARAMS, 0, 0}, 
    25532589    { NXopengroup_this, "NXOPENGROUP", 0, IDL_MAXPARAMS, 0, 0}, 
  • tags/4.2.1/bindings/idl/NeXusIDL-API.dlm

    r1924 r1924  
    88FUNCTION        NXOPENPATH 0    IDL_MAXPARAMS 
    99FUNCTION        NXOPENGROUPPATH 0       IDL_MAXPARAMS 
     10FUNCTION        NXGETPATH       0       IDL_MAXPARAMS 
    1011FUNCTION        NXMAKEGROUP 0   IDL_MAXPARAMS 
    1112FUNCTION        NXCLOSEGROUP 0  IDL_MAXPARAMS 
  • tags/4.2.1/bindings/java/Makefile.am

    r1924 r1924  
    5858# jni definitions 
    5959lib_LTLIBRARIES         = libjnexus.la 
     60AM_LDFLAGS=-version-info $(NXLTVERSINFO) 
    6061libjnexus_la_SOURCES    = native/hdfnativeImp.c \ 
    6162                       native/hdfexceptionImp.c \ 
  • tags/4.2.1/bindings/java/native/NexusFile.c

    r1924 r1924  
    2121 
    2222   Updated for 64 bit types, Mark Koennecke, August 2007 
     23 
     24   Added NXinitattrdir and NXinitgroupdir, Mark Koennecke, October 2009 
     25 
     26   Added NXgetpath, Mark Koennecke, October 2009 
    2327 
    2428   IMPLEMENTATION NOTES 
     
    3337   the integer first before it can do useful work. 
    3438 
    35  
    3639*/ 
    3740#include <stdlib.h> 
     
    4952#endif 
    5053 
    51 //#define DEBUG  
    52 #ifdef DEBUG 
    53 static FILE *fd = NULL; 
    54 #endif 
     54/* #define DEBUG */ 
     55 
     56static JavaVM *jvm;  // Global variable 
     57 
     58JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) { 
     59    JNIEnv *env; 
     60    jclass nexusException;   
     61 
     62    jint ret = (*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_1); 
     63 
     64    assert(ret == JNI_OK); 
     65 
     66    jvm = vm; 
     67 
     68    nexusException = (*env)->FindClass(env,"org/nexusformat/NexusException"); 
     69    if (nexusException == NULL) { 
     70        fprintf(stderr, "cannot find NexusException - this will not work. Terminating."); 
     71        assert(nexusException); 
     72    } 
     73 
     74    return JNI_VERSION_1_1; 
     75} 
    5576 
    5677/*--------------------------------------------------------------------------- 
    5778                              ERROR TREATMENT 
    5879 
    59   The NAPI writes any errors to stdout through a special function.  
    60   This is not very feasible in a Java environment where an exception should 
    61   be thrown. Fortunately it is possible to define an own error processing 
    62   function to be used for error processing. This error handling function 
    63   is defined here. A NexusException is constructed and thrown. 
     80  The NAPI posts any errors to a customisable function.  
     81  We construct and throw a NexusException with the message received. 
    6482  --------------------------------------------------------------------------*/ 
    65 static void JapiError(void *pData, char *text) 
    66 { 
    67     JNIEnv *env = (JNIEnv *)pData; 
    68     jclass jc; 
    69     jmethodID jm; 
    70     jobject exception; 
    71     jstring jtext; 
    72     char *args[2]; 
    73  
    74     assert(env); 
     83static void JapiError(void *pData, char *text) { 
     84    JNIEnv *env = pData; 
     85    jclass nexusException;   
    7586 
    7687#ifdef DEBUG 
    77     fprintf(fd,"JapiError called with: %s\n", text);  
    78 #endif 
    79     jc = (*env)->FindClass(env,"org/nexusformat/NexusException"); 
    80     assert(jc); 
    81     jm = (*env)->GetMethodID(env, jc, "<init>","(Ljava/lang/String;)V"); 
    82     assert(jm != NULL); 
    83     jtext = (*env)->NewStringUTF(env,text); 
    84     args[0] = (char *)jtext; 
    85     args[1] = 0; 
    86     exception = (*env)->NewObjectA(env, jc, jm, (jvalue *) args); 
    87     (*env)->Throw(env, exception); 
     88    fprintf(stderr,"JapiError called with: %s\n", text);  
     89#endif 
     90 
     91    /* ignore env passed in seems safer */ 
     92    (*jvm)->AttachCurrentThread (jvm, (void **) &env, NULL); 
     93 
     94    if (env == NULL) { 
     95        // if there is no thread environment we do not need to throw an exception 
     96        return; 
     97    } 
     98 
     99    // Find and store the NexusException class for use in JapiError 
     100    nexusException = (*env)->FindClass(env,"org/nexusformat/NexusException"); 
     101    (*env)->ThrowNew(env, nexusException, text); 
    88102}  
    89103 
     
    98112    int iRet; 
    99113 
    100 #ifdef DEBUG 
    101     if(fd == NULL) 
    102     { 
    103         fd = fopen("jnexusdebug.dat","w"); 
    104     } 
    105 #endif     
    106     /* set error handler */ 
    107     NXMSetError(env,JapiError); 
     114    /* set error handler */ 
     115    NXMSetTError(env,JapiError); 
    108116 
    109117    /* extract the filename as a C char* */ 
    110     fileName = (char *) (*env)->GetStringUTFChars(env,filename,0);     
     118    fileName = (char *) (*env)->GetStringUTFChars(env, filename, 0);     
    111119     
    112120    /* call NXopen */ 
    113121#ifdef DEBUG 
    114     fprintf(fd,"Calling NXopen on %s, with %d\n", fileName,access); 
     122    fprintf(stderr,"Calling NXopen on %s, with %d\n", fileName, access); 
    115123#endif 
    116124    iRet = NXopen(fileName,access,&handle); 
    117125 
    118126#ifdef DEBUG 
    119     fprintf(fd,"Handle %d allocated for %s\n", handle, fileName); 
     127    fprintf(stderr,"Handle allocated for %s\n", fileName); 
    120128#endif 
    121129 
     
    142150 
    143151    /* set error handler */ 
    144     NXMSetError(env,JapiError); 
     152    NXMSetTError(env,JapiError); 
    145153 
    146154    /* exchange the Java handler to a NXhandle */ 
     
    149157    /* kill handle */ 
    150158    HHRemoveHandle(handle); 
    151  
    152159 
    153160    /* call NXflush */ 
     
    173180 
    174181    /* set error handler */ 
    175     NXMSetError(env,JapiError); 
     182    NXMSetTError(env,JapiError); 
    176183 
    177184    /* exchange the Java handler to a NXhandle */ 
    178185    nxhandle =  (NXhandle)HHGetPointer(handle); 
    179186#ifdef DEBUG 
    180     fprintf(fd,"closing handle %d, nxhandle %d\n", handle, nxhandle); 
     187    fprintf(stderr,"closing handle %d, nxhandle %d\n", handle, nxhandle); 
    181188#endif 
    182189 
     
    197204 
    198205    /* set error handler */ 
    199     NXMSetError(env,JapiError); 
     206    NXMSetTError(env,JapiError); 
    200207 
    201208    /* exchange the Java handler to a NXhandle */ 
     
    224231 
    225232    /* set error handler */ 
    226     NXMSetError(env,JapiError); 
     233    NXMSetTError(env,JapiError); 
    227234 
    228235    /* exchange the Java handler to a NXhandle */ 
     
    238245    if(iRet != NX_OK) 
    239246    { 
    240       fprintf(fd,"Cleanup code called after raising Exception\n"); 
     247      fprintf(stderr,"Cleanup code called after raising Exception\n"); 
    241248    } 
    242249#endif 
     
    256263 
    257264    /* set error handler */ 
    258     NXMSetError(env,JapiError); 
     265    NXMSetTError(env,JapiError); 
    259266 
    260267    /* exchange the Java handler to a NXhandle */ 
     
    269276    if(iRet != NX_OK) 
    270277    { 
    271       fprintf(fd,"Cleanup code called after raising Exception\n"); 
     278      fprintf(stderr,"Cleanup code called after raising Exception\n"); 
    272279    } 
    273280#endif 
     
    286293 
    287294    /* set error handler */ 
    288     NXMSetError(env,JapiError); 
     295    NXMSetTError(env,JapiError); 
    289296 
    290297    /* exchange the Java handler to a NXhandle */ 
     
    299306    if(iRet != NX_OK) 
    300307    { 
    301       fprintf(fd,"Cleanup code called after raising Exception\n"); 
     308      fprintf(stderr,"Cleanup code called after raising Exception\n"); 
    302309    } 
    303310#endif 
     
    305312    (*env)->ReleaseStringUTFChars(env,path, nxpath); 
    306313} 
     314/*-----------------------------------------------------------------------*/ 
     315JNIEXPORT jstring JNICALL Java_org_nexusformat_NexusFile_nxgetpath 
     316  (JNIEnv *env, jobject obj, jint handle) 
     317{ 
     318    NXhandle nxhandle; 
     319    int iRet; 
     320    char path[1024]; 
     321 
     322    /* set error handler */ 
     323    NXMSetTError(env,JapiError); 
     324 
     325    /* exchange the Java handler to a NXhandle */ 
     326    nxhandle =  (NXhandle)HHGetPointer(handle); 
     327 
     328    iRet = NXgetpath(nxhandle, path,1024); 
     329     
     330    return (*env)->NewStringUTF(env,path); 
     331} 
     332 
    307333/*------------------------------------------------------------------------ 
    308334                     nxclosegroup 
     
    315341 
    316342    /* set error handler */ 
    317     NXMSetError(env,JapiError); 
     343    NXMSetTError(env,JapiError); 
    318344 
    319345    /* exchange the Java handler to a NXhandle */ 
     
    336362 
    337363    /* set error handler */ 
    338     NXMSetError(env,JapiError); 
     364    NXMSetTError(env,JapiError); 
    339365 
    340366    /* exchange the Java handler to a NXhandle */ 
     
    367393 
    368394    /* set error handler */ 
    369     NXMSetError(env,JapiError); 
     395    NXMSetTError(env,JapiError); 
    370396 
    371397    /* exchange the Java handler to a NXhandle */ 
     
    401427 
    402428    /* set error handler */ 
    403     NXMSetError(env,JapiError); 
     429    NXMSetTError(env,JapiError); 
    404430 
    405431    /* exchange the Java handler to a NXhandle */ 
     
    424450 
    425451    /* set error handler */ 
    426     NXMSetError(env,JapiError); 
     452    NXMSetTError(env,JapiError); 
    427453 
    428454    /* exchange the Java handler to a NXhandle */ 
     
    442468 
    443469    /* set error handler */ 
    444     NXMSetError(env,JapiError); 
     470    NXMSetTError(env,JapiError); 
    445471 
    446472    /* exchange the Java handler to a NXhandle */ 
     
    448474 
    449475#ifdef DEBUG 
    450     fprintf(fd,"Compressing at %d with type %d\n", nxhandle, comp_type); 
     476    fprintf(stderr,"Compressing at %d with type %d\n", nxhandle, comp_type); 
    451477#endif 
    452478    iRet = NXcompress(nxhandle,comp_type); 
     
    463489 
    464490    /* set error handler */ 
    465     NXMSetError(env,JapiError); 
     491    NXMSetTError(env,JapiError); 
    466492 
    467493    /* exchange the Java handler to a NXhandle */ 
     
    478504    if(iRet != NX_OK) 
    479505    { 
    480         HEprint(fd,0); 
     506        HEprint(stderr,0); 
    481507    } 
    482508#endif 
     
    495521 
    496522    /* set error handler */ 
    497     NXMSetError(env,JapiError); 
     523    NXMSetTError(env,JapiError); 
    498524 
    499525    /* exchange the Java handler to a NXhandle */ 
     
    526552 
    527553    /* set error handler */ 
    528     NXMSetError(env,JapiError); 
     554    NXMSetTError(env,JapiError); 
    529555 
    530556    /* exchange the Java handler to a NXhandle */ 
     
    579605 
    580606    /* set error handler */ 
    581     NXMSetError(env,JapiError); 
     607    NXMSetTError(env,JapiError); 
    582608 
    583609    /* exchange the Java handler to a NXhandle */ 
     
    594620    if(iRet != NX_OK) 
    595621    { 
    596         HEprint(fd,0); 
     622        HEprint(stderr,0); 
    597623    } 
    598624#endif 
     
    611637 
    612638    /* set error handler */ 
    613     NXMSetError(env,JapiError); 
     639    NXMSetTError(env,JapiError); 
    614640 
    615641    /* exchange the Java handler to a NXhandle */ 
     
    644670 
    645671    /* set error handler */ 
    646     NXMSetError(env,JapiError); 
     672    NXMSetTError(env,JapiError); 
    647673 
    648674    /* exchange the Java handler to a NXhandle */ 
     
    654680    iargs = (*env)->GetIntArrayElements(env,args,0); 
    655681#ifdef DEBUG 
    656     fprintf(fd,"nxgetattr converted types \n"); 
     682    fprintf(stderr,"nxgetattr converted types \n"); 
    657683#endif 
    658684 
     
    660686    iType = iargs[1]; 
    661687#ifdef DEBUG 
    662     fprintf(fd,"nxgetattr: iLen %d, iType: %d\n",iLen, iType); 
     688    fprintf(stderr,"nxgetattr: iLen %d, iType: %d\n",iLen, iType); 
    663689#endif 
    664690 
     
    667693    iargs[1] = iType; 
    668694#ifdef DEBUG 
    669     fprintf(fd,"nxgetattr cleaning up \n"); 
     695    fprintf(stderr,"nxgetattr cleaning up \n"); 
    670696#endif 
    671697 
     
    689715 
    690716    /* set error handler */ 
    691     NXMSetError(env,JapiError); 
     717    NXMSetTError(env,JapiError); 
    692718 
    693719    /* exchange the Java handler to a NXhandle */ 
     
    701727        if(cls == NULL) 
    702728        { 
    703             NXIReportError(env, 
     729            JapiError(env, 
    704730               "ERROR: failed to locate class in nxgetgroupid"); 
    705731            return; 
     
    708734        if(fid == 0) 
    709735        { 
    710             NXIReportError(env, 
     736            JapiError(env, 
    711737               "ERROR: failed to locate fieldID in nxgetgroupid"); 
    712738            return; 
     
    717743        if(fid == 0) 
    718744        { 
    719             NXIReportError(env, 
     745            JapiError(env, 
    720746               "ERROR: failed to locate fieldID in nxgetgroupid"); 
    721747            return; 
     
    730756        if(fid == 0) 
    731757        { 
    732             NXIReportError(env, 
     758            JapiError(env, 
    733759               "ERROR: failed to locate targetPath in nxgetgroupid"); 
    734760            return; 
     
    740766        if(fid == 0) 
    741767        { 
    742             NXIReportError(env, 
     768            JapiError(env, 
    743769               "ERROR: failed to locate linkType in nxgetgroupid"); 
    744770            return; 
     
    750776        if(fid == 0) 
    751777        { 
    752             NXIReportError(env, 
     778            JapiError(env, 
    753779               "ERROR: failed to locate targetPath in nxgetgroupid"); 
    754780            return; 
     
    772798 
    773799    /* set error handler */ 
    774     NXMSetError(env,JapiError); 
     800    NXMSetTError(env,JapiError); 
    775801 
    776802    /* exchange the Java handler to a NXhandle */ 
     
    784810        if(cls == NULL) 
    785811        { 
    786             NXIReportError(env, 
     812            JapiError(env, 
    787813               "ERROR: failed to locate class in nxgetdataid"); 
    788814            return; 
     
    791817        if(fid == 0) 
    792818        { 
    793             NXIReportError(env, 
     819            JapiError(env, 
    794820               "ERROR: failed to locate fieldID in nxgetdataid"); 
    795821            return; 
     
    799825        if(fid == 0) 
    800826        { 
    801             NXIReportError(env, 
     827            JapiError(env, 
    802828               "ERROR: failed to locate fieldID in nxgetdataid"); 
    803829            return; 
     
    812838        if(fid == 0) 
    813839        { 
    814             NXIReportError(env, 
     840            JapiError(env, 
    815841               "ERROR: failed to locate targetPath in nxgetgroupid"); 
    816842            return; 
     
    822848        if(fid == 0) 
    823849        { 
    824             NXIReportError(env, 
     850            JapiError(env, 
    825851               "ERROR: failed to locate linkType in nxgetgroupid"); 
    826852            return; 
     
    832858        if(fid == 0) 
    833859        { 
    834             NXIReportError(env, 
     860            JapiError(env, 
    835861               "ERROR: failed to locate targetPath in nxgetdataid"); 
    836862            return; 
     
    856882 
    857883    /* set error handler */ 
    858     NXMSetError(env,JapiError); 
     884    NXMSetTError(env,JapiError); 
    859885 
    860886    /* exchange the Java handler to a NXhandle */ 
     
    865891    if(cls == NULL) 
    866892    { 
    867          NXIReportError(env, 
     893         JapiError(env, 
    868894               "ERROR: failed to locate class in nxmakelink"); 
    869895         return; 
     
    872898     if(fid == 0) 
    873899     { 
    874           NXIReportError(env, 
     900          JapiError(env, 
    875901               "ERROR: failed to locate fieldID in nxmakelink"); 
    876902          return; 
     
    880906     if(fid == 0) 
    881907     { 
    882           NXIReportError(env, 
     908          JapiError(env, 
    883909               "ERROR: failed to locate fieldID in nxmakelink"); 
    884910          return; 
     
    893919     if(fid == 0) 
    894920     { 
    895           NXIReportError(env, 
     921          JapiError(env, 
    896922               "ERROR: failed to locate targetPath in nxmakelink"); 
    897923          return; 
     
    905931     if(fid == 0) 
    906932     { 
    907           NXIReportError(env, 
     933          JapiError(env, 
    908934               "ERROR: failed to locate linkType in nxmakelink"); 
    909935          return; 
     
    915941     if(fid == 0) 
    916942     { 
    917           NXIReportError(env, 
     943          JapiError(env, 
    918944               "ERROR: failed to locate targetPath in nxmakelink"); 
    919945          return; 
     
    943969 
    944970    /* set error handler */ 
    945     NXMSetError(env,JapiError); 
     971    NXMSetTError(env,JapiError); 
    946972 
    947973    /* exchange the Java handler to a NXhandle */ 
     
    955981    if(cls == NULL) 
    956982    { 
    957          NXIReportError(env, 
     983         JapiError(env, 
    958984               "ERROR: failed to locate class in nxmakelink"); 
    959985         return; 
     
    962988     if(fid == 0) 
    963989     { 
    964           NXIReportError(env, 
     990          JapiError(env, 
    965991               "ERROR: failed to locate fieldID in nxmakelink"); 
    966992          return; 
     
    970996     if(fid == 0) 
    971997     { 
    972           NXIReportError(env, 
     998          JapiError(env, 
    973999               "ERROR: failed to locate fieldID in nxmakelink"); 
    9741000          return; 
     
    9831009     if(fid == 0) 
    9841010     { 
    985           NXIReportError(env, 
     1011          JapiError(env, 
    9861012               "ERROR: failed to locate targetPath in nxmakelink"); 
    9871013          return; 
     
    9951021     if(fid == 0) 
    9961022     { 
    997           NXIReportError(env, 
     1023          JapiError(env, 
    9981024               "ERROR: failed to locate linkType in nxmakelink"); 
    9991025          return; 
     
    10051031     if(fid == 0) 
    10061032     { 
    1007           NXIReportError(env, 
     1033          JapiError(env, 
    10081034               "ERROR: failed to locate targetPath in nxmakelink"); 
    10091035          return; 
     
    10291055 
    10301056    /* set error handler */ 
    1031     NXMSetError(env,JapiError); 
     1057    NXMSetTError(env,JapiError); 
    10321058 
    10331059    /* exchange the Java handler to a NXhandle */ 
     
    10481074 
    10491075   /* set error handler */ 
    1050     NXMSetError(env,JapiError); 
     1076    NXMSetTError(env,JapiError); 
    10511077 
    10521078    /* exchange the Java handler to a NXhandle */ 
     
    10781104 
    10791105   /* set error handler */ 
    1080     NXMSetError(env,JapiError); 
     1106    NXMSetTError(env,JapiError); 
    10811107 
    10821108    /* exchange the Java handler to a NXhandle */ 
     
    11131139 
    11141140   /* set error handler */ 
    1115     NXMSetError(env,JapiError); 
     1141    NXMSetTError(env,JapiError); 
    11161142 
    11171143    /* exchange the Java handler to a NXhandle */ 
     
    11411167    jint *jarray; 
    11421168   /* set error handler */ 
    1143     NXMSetError(env,JapiError); 
     1169    NXMSetTError(env,JapiError); 
    11441170 
    11451171    /* exchange the Java handler to a NXhandle */ 
     
    11681194 
    11691195   /* set error handler */ 
    1170     NXMSetError(env,JapiError); 
     1196    NXMSetTError(env,JapiError); 
    11711197 
    11721198    /* exchange the Java handler to a NXhandle */ 
     
    11871213 
    11881214    /* set error handler */ 
    1189     NXMSetError(env,JapiError); 
     1215    NXMSetTError(env,JapiError); 
    11901216 
    11911217    /* exchange the Java handler to a NXhandle */ 
     
    12131239     
    12141240    /* set error handler */ 
    1215     NXMSetError(env,JapiError); 
     1241    NXMSetTError(env,JapiError); 
    12161242 
    12171243    /* exchange the Java handler to a NXhandle */ 
     
    12331259    } 
    12341260} 
     1261/*---------------------------------------------------------------------*/ 
     1262JNIEXPORT void JNICALL Java_org_nexusformat_NexusFile_initattrdir 
     1263(JNIEnv *env, jobject obj, jint handle) 
     1264{ 
     1265    NXhandle nxhandle; 
     1266    int iRet; 
     1267 
     1268    /* set error handler */ 
     1269    NXMSetTError(env,JapiError); 
     1270 
     1271    /* exchange the Java handler to a NXhandle */ 
     1272    nxhandle =  (NXhandle)HHGetPointer(handle); 
     1273 
     1274    iRet = NXinitattrdir(nxhandle); 
     1275 
     1276} 
     1277/*---------------------------------------------------------------------*/ 
     1278JNIEXPORT void JNICALL Java_org_nexusformat_NexusFile_initgroupdir 
     1279(JNIEnv *env, jobject obj, jint handle) 
     1280{ 
     1281    NXhandle nxhandle; 
     1282    int iRet; 
     1283 
     1284    /* set error handler */ 
     1285    NXMSetTError(env,JapiError); 
     1286 
     1287    /* exchange the Java handler to a NXhandle */ 
     1288    nxhandle =  (NXhandle)HHGetPointer(handle); 
     1289 
     1290    iRet = NXinitgroupdir(nxhandle); 
     1291} 
    12351292/*------------------------------------------------------------------------ 
    12361293                               debugstop 
     
    12471304   } 
    12481305} 
    1249  
    1250  
    1251  
    1252  
    1253  
    1254  
    1255  
    1256  
    1257  
  • tags/4.2.1/bindings/java/org/nexusformat/NeXusFileInterface.java

    r1924 r1924  
    8989    public void opengrouppath(String path) throws  
    9090                           NexusException; 
     91    /** 
     92     * return the current path into the NeXus file in the  
     93     * form of a Unix path string. 
     94     * @return A unix path string 
     95     */ 
     96    public String getpath() throws NexusException; 
    9197    /** 
    9298      * closegroup closes access to the current group and steps down one 
  • tags/4.2.1/bindings/java/org/nexusformat/NexusFile.java

    r1924 r1924  
    1616  * 
    1717  * copyright: see accompanying COPYRIGHT file 
     18  * 
     19  * added nxinitattrdir: Mark Koennecke, October 2009  
    1820  */ 
    1921package org.nexusformat; 
     
    111113    protected native void close(int handle); 
    112114    protected native int  nxflush(int handle); 
    113  
     115     
    114116    /** 
    115117      * constructs a new NexusFile Object. 
     
    134136    public NexusFile(String filename, int access) throws NexusException  
    135137    { 
     138         checkForNull(filename); 
    136139         handle = init(filename,access); 
    137140         if(handle < 0){ 
     
    182185    protected native void nxopengrouppath(int handle, String path); 
    183186    protected native void nxclosegroup(int handle); 
     187    protected native String nxgetpath(int handle); 
    184188 
    185189    /**  
     
    193197                            NexusException 
    194198    { 
     199        checkForNull(name, nxclass); 
    195200        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
    196201        nxmakegroup(handle, name, nxclass); 
     
    208213    { 
    209214        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
     215        checkForNull(name, nxclass); 
    210216        nxopengroup(handle, name, nxclass); 
    211217    } 
     
    222228    { 
    223229        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
    224         nxopenpath(handle,path); 
     230        checkForNull(path); 
     231        nxopenpath(handle, path); 
    225232    } 
    226233    /** 
     
    236243    { 
    237244        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
     245        checkForNull(path); 
    238246        nxopengrouppath(handle,path); 
    239247    } 
    240  
     248    /** 
     249     * return the current path into the NeXus file in the  
     250     * form of a Unix path string. 
     251     * @return A unix path string 
     252     */ 
     253    public String getpath() throws NexusException  
     254    { 
     255        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
     256        return nxgetpath(handle); 
     257    } 
    241258    /** 
    242259      * closegroup closes access to the current group and steps down one 
     
    283300                             NexusException { 
    284301        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
    285         checkType(type); 
     302        checkType(type);     
     303        checkForNull(name); 
    286304        switch(compression_type) { 
    287305        case NexusFile.NX_COMP_NONE: 
     
    307325      * @exception NexusException when the dataset could not be created. 
    308326      */  
    309     public void makedata(String name, int type, int rank, int dim[]) throws 
     327    public void makedata(String name, int type, int rank, int[] dim) throws 
    310328                           NexusException 
    311329    { 
    312330        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
    313331        checkType(type); 
     332        checkForNull(name, dim); 
    314333        nxmakedata(handle,name,type,rank,dim); 
    315334    } 
     
    325344    { 
    326345        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
     346        checkForNull(name); 
    327347        nxopendata(handle,name); 
    328348    } 
     
    386406        byte bdata[]; 
    387407        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
     408        checkForNull(array); 
    388409        try{ 
    389410            HDFArray ha = new HDFArray(array); 
     
    406427      * the data. 
    407428      */ 
    408     public void getslab(int start[], int size[],Object array)throws 
     429    public void getslab(int[] start, int[] size, Object array) throws 
    409430                          NexusException 
    410431    { 
    411432        byte bdata[]; 
    412433        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
     434        checkForNull(start, size, array); 
    413435        try{ 
    414436            HDFArray ha = new HDFArray(array); 
    415437            bdata = ha.emptyBytes(); 
    416             nxgetslab(handle,start,size,bdata); 
     438            nxgetslab(handle, start, size, bdata); 
    417439            array = ha.arrayify(bdata); 
    418440         }catch(HDFException he) { 
     
    432454      * the attribute could not be found. 
    433455      */ 
    434     public void getattr(String name,Object array, int args[])throws 
     456    public void getattr(String name, Object array, int[] args)throws 
    435457                          NexusException 
    436458    { 
    437459        byte bdata[]; 
    438460        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
     461        checkForNull(name, array, args); 
    439462        checkType(args[1]); 
    440463        try{ 
     
    468491 
    469492       if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
     493           checkForNull(array); 
     494 
    470495       try{ 
    471496           HDFArray ha =  new HDFArray(array); 
     
    488513      * @exception NexusException when an HDF error occurs. 
    489514      */  
    490     public void putslab(Object array, int start[], int size[]) throws 
     515    public void putslab(Object array, int[] start, int[] size) throws 
    491516                          NexusException 
    492517    { 
     
    494519 
    495520       if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
     521       checkForNull(array, start, size); 
    496522       try{ 
    497523           HDFArray ha =  new HDFArray(array); 
     
    501527           throw new NexusException(he.getMessage()); 
    502528       } 
    503        nxputslab(handle,data,start,size); 
     529       nxputslab(handle, data, start, size); 
    504530       data = null; 
    505531    } 
     
    519545       if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
    520546       checkType(iType); 
     547       checkForNull(name, array); 
    521548       try{ 
    522549           HDFArray ha =  new HDFArray(array); 
     
    537564    protected native int nextentry(int handle, String names[]); 
    538565    protected native int nextattr(int handle, String names[], int args[]); 
     566    protected native void initattrdir(int handle); 
     567    protected native void initgroupdir(int handle); 
    539568    /** 
    540569     * setnumberformat sets the number format for printing number when 
     
    549578        throws NexusException{ 
    550579       if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
     580       checkType(type); 
     581       checkForNull(format); 
    551582       nxsetnumberformat(handle,type,format); 
    552583    } 
     
    581612        String names[] = new String[2]; 
    582613        int i; 
     614 
     615        initgroupdir(handle); 
    583616        while(nextentry(handle,names) != -1) 
    584617        { 
     
    603636        Hashtable h = new Hashtable(); 
    604637        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
     638        initattrdir(handle); 
    605639        while(nextattr(handle,names,args) != -1) 
    606640        { 
     
    654688      * @exception NexusException if an error occurs. 
    655689      */ 
    656     public void   makelink(NXlink target)throws 
     690    public void makelink(NXlink target) throws 
    657691                          NexusException 
    658692    { 
    659693      if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
    660       nxmakelink(handle,target); 
     694      checkForNull(target); 
     695      nxmakelink(handle, target); 
    661696    } 
    662697    /** 
     
    668703      * @exception NexusException if an error occurs. 
    669704      */ 
    670     public void   makenamedlink(String name, NXlink target)throws 
     705    public void makenamedlink(String name, NXlink target) throws 
    671706        NexusException { 
    672707      if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
    673       nxmakenamedlink(handle,name, target); 
     708      checkForNull(name, target); 
     709      nxmakenamedlink(handle, name, target); 
    674710    }      
    675711 
     
    679715      * @exception NexusException if an error occurs. 
    680716      */ 
    681     public void   opensourcepath()throws 
     717    public void opensourcepath() throws 
    682718                          NexusException 
    683719    { 
     
    686722    } 
    687723         
    688  
     724    /** 
     725     * checks if any of the arguments is null,  
     726     * throws appropriate runtime exception if so 
     727     */ 
     728    private void checkForNull(Object... args) { 
     729        for (Object o : args) 
     730                if (o==null) throw new NullPointerException(); 
     731    } 
     732     
    689733    /** 
    690734      * checkType verifies if a parameter is a valid NeXus type code.  
     
    696740    { 
    697741        switch(type) { 
     742        case NexusFile.NX_FLOAT32: 
     743        case NexusFile.NX_FLOAT64: 
    698744        case NexusFile.NX_INT8: 
    699745        case NexusFile.NX_UINT8: 
    700         case NexusFile.NX_CHAR: 
    701746        case NexusFile.NX_INT16: 
    702747        case NexusFile.NX_UINT16: 
    703748        case NexusFile.NX_INT32: 
    704749        case NexusFile.NX_UINT32: 
    705         case NexusFile.NX_FLOAT32: 
    706         case NexusFile.NX_FLOAT64: 
     750        case NexusFile.NX_INT64: 
     751        case NexusFile.NX_UINT64: 
     752        case NexusFile.NX_CHAR: 
    707753            break; 
    708754        default: 
     
    735781     * @throws NexusException if things are wrong 
    736782     */ 
    737     public void linkexternal(String name, String nxclass, String nxurl) throws NexusException{ 
    738         if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
    739         nxlinkexternal(handle,name,nxclass,nxurl); 
     783    public void linkexternal(String name, String nxclass, String nxurl) throws NexusException { 
     784        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
     785        checkForNull(name, nxclass, nxurl); 
     786        nxlinkexternal(handle, name, nxclass, nxurl); 
    740787    } 
    741788    /** 
     
    749796    public String isexternalgroup(String name, String nxclass) throws NexusException{ 
    750797        if(handle < 0) throw new NexusException("NAPI-ERROR: File not open"); 
     798        checkForNull(name, nxclass); 
    751799        String nxurl[] = new String[1]; 
    752800 
     
    770818    public native void debugstop(); 
    771819} 
    772    
    773  
    774  
    775  
    776  
    777  
    778  
    779  
    780  
  • tags/4.2.1/bindings/python/Makefile.am

    r1924 r1924  
    3535#pkgpython_PYTHON = nxstest.py 
    3636nxspython_PYTHON = nxs/__init__.py nxs/napi.py 
    37 EXTRA_DIST      = README.html nxstest.py run_nxstest 
     37EXTRA_DIST      = README.html nxstest.py run_nxstest setup.py 
    3838 
    3939install-data-hook : 
  • tags/4.2.1/bindings/swig/nxinter.i

    r1924 r1924  
    5757extern int nx_openpath(void *handle, char *path); 
    5858extern int nx_opengrouppath(void *handle, char *path); 
     59extern char *nx_getpath(void *handle); 
    5960extern int nx_closegroup(void *handle); 
    6061extern char *nx_getnextentry(void *handle, char separator); 
  • tags/4.2.1/bindings/swig/nxinterhelper.c

    r1924 r1924  
    114114} 
    115115/*--------------------------------------------------------------------*/ 
     116char *nx_getpath(void *handle){ 
     117  int status; 
     118  NXhandle hfil; 
     119  char path[1024]; 
     120 
     121  hfil = (NXhandle)handle; 
     122  status = NXgetpath(hfil,path,1024); 
     123  if(status == NX_OK){ 
     124    return strdup(path); 
     125  } else { 
     126    return strdup("Error in NXgetpath"); 
     127  } 
     128} 
     129/*--------------------------------------------------------------------*/ 
    116130int nx_closegroup(void *handle){ 
    117131  int status; 
  • tags/4.2.1/bindings/swig/nxinterhelper.h

    r1924 r1924  
    2323int nx_opengrouppath(void *handle, char *path); 
    2424int nx_openpath(void *handle, char *path); 
     25extern char *nx_getpath(void *handle); 
    2526int nx_closegroup(void *handle); 
    2627char *nx_getnextentry(void *handle, char separator); 
  • tags/4.2.1/configure.ac

    r1924 r1924  
    3131AC_PREREQ(2.61) 
    3232AC_REVISION($Revision$) 
    33 AC_INIT([NeXus Library], [4.2.0], [nexus-developers@nexusformat.org], [nexus]) 
     33AC_INIT([NeXus Library], [4.2.1], [nexus-developers@nexusformat.org], [nexus]) 
    3434AC_COPYRIGHT([Copyright (C) 2004 NeXus International Advisory Committee 
    3535This software is covered by the GNU LESSER GENERAL PUBLIC LICENSE 
    3636see file COPYING for further information]) 
     37 
     38# used by libtool - need to get if from 4.2.1 better 
     39NXLTVERSINFO="4:2:4" 
    3740 
    3841AC_CONFIG_AUX_DIR(config) 
     
    5558AM_INIT_AUTOMAKE([1.6]) 
    5659 
     60AC_SUBST(NXLTVERSINFO) 
    5761 
    5862AM_CONFIG_HEADER(include/nxconfig.h:include/nxconfig_h.in) 
     
    8286fi 
    8387 
     88AC_SUBST(WITH_F77) 
    8489AC_ARG_WITH([f77], AC_HELP_STRING([--with-f77=f77 compiler], [Specify name of FORTRAN 77 compiler]), 
    85         [with_f77=$withval], [with_f77=no]) 
    86 if test x"$with_f77" != x"no" ; then 
     90        [], [with_f77=no]) 
     91if test ! -z "$with_f77" -a x"$with_f77" != x"no" ; then 
    8792        if test x"$with_f77" != x"yes" ; then F77="$with_f77"; fi 
    8893        AC_PROG_F77 
     
    9499        AC_CHECK_F77_OPTION([-I$mytop/bindings/f77],[      INCLUDE 'napif.inc']) 
    95100        AC_F77_LIBRARY_LDFLAGS 
     101        WITH_F77=yes 
    96102else 
    97103        F77= 
    98 fi 
    99  
     104        WITH_F77=no 
     105fi 
     106 
     107AC_SUBST(WITH_F90) 
    100108AC_ARG_WITH([f90], AC_HELP_STRING([--with-f90=f90 compiler], [Specify name of FORTRAN 90 compiler]), 
    101         [with_f90=$withval], [with_f90=no]) 
    102 if test x"$with_f90" != x"no" ; then 
     109        [], [with_f90=no]) 
     110if test ! -z "$with_f90" -a x"$with_f90" != x"no" ; then 
    103111        if test x"$with_f90" = x"yes" ; then 
    104                 AC_CHECK_PROGS(FC, [g95 f90 f95 ifort]) 
     112                AC_CHECK_PROGS(FC, [g95 gfortran f90 f95 ifort]) 
    105113        else 
    106114                FC="$with_f90" 
     
    118126#        if test x$with_f77=xno; then with_f77=$FC; fi 
    119127#        if test x$with_f77=xno; then with_f77=yes; fi 
     128        WITH_F90=yes 
    120129else 
    121130        FC= 
    122 fi 
     131        WITH_F90=no 
     132fi 
     133 
     134AC_ARG_WITH([matlabroot], AC_HELP_STRING([--with-matlabroot=path to matlab install dir], [Specify location of matlab installation directory]), 
     135        [], [with_matlabroot=no]) 
     136if test x"$with_matlabroot" != x"no" ; then 
     137    MATLABROOT="$with_matlabroot" 
     138fi 
     139AC_PATH_PROG(MATLAB,matlab,[],[$MATLABROOT/bin:/usr/local/matlab/bin:/opt/matlab/bin:$PATH]) 
     140if test x"$MATLABROOT" = x -a x"$MATLAB" != x; then 
     141    MATLABROOT=`dirname $MATLAB`/.. 
     142fi 
     143 
     144dnl thread local storage 
     145AC_MSG_CHECKING([for __thread]) 
     146AC_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)) 
     147#endif], [static __thread int p = 0])], 
     148               [AC_DEFINE(HAVE_TLS, 1, 
     149                      Define to 1 if compiler supports __thread) 
     150                AC_MSG_RESULT([yes])], 
     151               [AC_MSG_RESULT([no])]) 
    123152 
    124153java_host="linux" 
     
    126155AC_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]), 
    127156        [], [with_java_home=$withval]) 
     157AC_ARG_WITH([java], AC_HELP_STRING([--with-java=path to java executable], [Specify location of JAVA executable]), 
     158        [], [with_java=no]) 
     159if test -z "$with_java_home" -a x$with_java != xno; then 
     160    def_javac=`which javac` 
     161    link_javac=`readlink -e "$def_javac"` 
     162    with_java_home=`dirname "$link_javac"`/.. 
     163fi 
    128164if test -d "$with_java_home"; then 
    129165        JAVAROOT="$with_java_home" 
    130166        AC_MSG_NOTICE([Java SDK home is $JAVAROOT]) 
    131167        JAVAINCLUDE="-I$JAVAROOT/include" 
    132         AC_PATH_PROGS(JAVAC,gcj javac,,[$JAVAROOT/bin]) 
     168        AC_PATH_PROGS(JAVAC,javac gcj,,[$JAVAROOT/bin]) 
    133169        if test `basename "$JAVAC"` = "gcj"; then 
    134170            JAVACFLAGS="-C"     # force creation of .class files 
    135171        fi 
    136         AC_PATH_PROGS(JAVA,gij java,,[$JAVAROOT/bin]) 
    137         AC_PATH_PROGS(JAVAH,gcjh javah,,[$JAVAROOT/bin]) 
     172        AC_PATH_PROGS(JAVA,java gij,,[$JAVAROOT/bin]) 
     173        AC_PATH_PROGS(JAVAH,javah gcjh,,[$JAVAROOT/bin]) 
    138174        AC_PATH_PROGS(JAVADOC,javadoc,,[$JAVAROOT/bin:$PATH]) 
    139175        AC_PATH_PROGS(JAR,jar fastjar,,[$JAVAROOT/bin:$PATH]) 
     
    212248test -z "$PACKAGE_RELEASE" && PACKAGE_RELEASE=1 
    213249 
     250SHARED_LDFLAGS="" 
     251 
    214252NXDOCDIR='${datadir}/nexus/doc' 
    215253NXEXAMPLEDIR='${datadir}/nexus/examples' 
     
    244282    fi 
    245283    AM_PATH_PYTHON(,, :) 
     284    AC_CHECK_PYTHON_MODULE(numpy) 
    246285fi 
    247286 
     
    297336 
    298337# strict aliasing causes issues with casts from NXmalloc() 
    299 CFLAGS="-fno-strict-aliasing" 
    300 CXXFLAGS="-fno-strict-aliasing" 
     338CFLAGS="$CFLAGS -fno-strict-aliasing" 
     339CXXFLAGS="$CXXFLAGS -fno-strict-aliasing" 
    301340 
    302341# check for debug 
     
    375414 
    376415    *mingw*) 
    377         SHARED_LDFLAGS="-no-undefined" #  -Wl,--add-stdcall-alias 
     416        SHARED_LDFLAGS="$SHARED_LDFLAGS -no-undefined" #  -Wl,--add-stdcall-alias 
    378417        MINGW_MSYS=yes 
    379418        HDF_EXT=dll 
     
    384423 
    385424    *cygwin*) 
    386 #       SHARED_LDFLAGS="-no-undefined" #  -Wl,--add-stdcall-alias 
     425#       SHARED_LDFLAGS="$SHARED_LDFLAGS -no-undefined" #  -Wl,--add-stdcall-alias 
    387426        ;; 
    388427 
     
    403442dnl     F90FLAGS="$F90FLAGS -g -cons -YEXT_NAMES=LCS -YEXT_SFX=_" 
    404443dnl     FCFLAGS="$FCFLAGS -qextname" 
    405         SHARED_LDFLAGS="-Wl,-single_module" 
     444        SHARED_LDFLAGS="$SHARED_LDFLAGS -Wl,-single_module" 
    406445#       LTF90COMPILETAG="--tag=F77" 
    407446#       LTF90LINKTAG="--tag=CC" 
     
    579618fi 
    580619# for Mac/fink when hdf and hdf5 are not taken from fink, but jpeg is 
    581 if test -d /sw/lib; then 
    582     LDFLAGS="$LDFLAGS -L/sw/lib" 
    583 fi 
     620#if test -d /sw/lib; then 
     621#    LDFLAGS="$LDFLAGS -L/sw/lib" 
     622#fi 
    584623# for Mac/Macports when you are not using fink at all. 
    585 if test -d /opt/local/lib; then 
    586     LDFLAGS="$LDFLAGS -L/opt/local/lib" 
    587 fi 
     624#if test -d /opt/local/lib; then 
     625#    LDFLAGS="$LDFLAGS -L/opt/local/lib" 
     626#fi 
    588627 
    589628# remove initial : 
     
    618657AC_CHECK_LIB(hdf5, H5open) 
    619658AC_CHECK_LIB(xml2, xmlParseDocument) 
     659AC_CHECK_LIB(readline, readline) 
     660AC_CHECK_LIB(history, add_history) 
     661dnl AC_LANG_PUSH([C++]) 
     662dnl AC_CHECK_LIB(mxmlplus, _ZN4MXML4NodeD2Ev) 
     663dnl AC_LANG_POP([C++]) 
    620664 
    621665dnl Checks for header files. 
     
    637681AC_TYPE_LONG_LONG_INT 
    638682AC_TYPE_UNSIGNED_LONG_LONG_INT 
    639 AC_CHECK_SIZEOF([int]) 
    640 AC_CHECK_SIZEOF([long int]) 
    641 AC_CHECK_SIZEOF([long long int]) 
     683dnl these are not compatible with cross architecture compiling 
     684if test x$cross_compiling != xyes; then 
     685    AC_CHECK_SIZEOF([int]) 
     686    AC_CHECK_SIZEOF([long int]) 
     687    AC_CHECK_SIZEOF([long long int]) 
     688fi 
    642689AC_STRUCT_TM 
    643690 
     
    672719AC_CHECK_FUNCS([ftime memset strchr strdup strrchr strstr tzset mkstemp]) 
    673720 
     721AC_CHECK_FUNC([rl_completion_matches]) 
     722 
    674723AM_CONDITIONAL(HAVE_CPP, [test ! -z "$CXX"]) 
    675724AM_CONDITIONAL(HAVE_F77, [test "$with_f77" != "no"]) 
    676725AM_CONDITIONAL(HAVE_F90, [test "$with_f90" != "no"]) 
    677 AM_CONDITIONAL(HAVE_PYTHON, [test ! -z "$PYTHONROOT"]) 
     726AM_CONDITIONAL(HAVE_PYTHON, [test ! -z "$PYTHONROOT" -a "$PYTHON_numpy" -eq 1]) 
    678727AM_CONDITIONAL(HAVE_TCL, [test ! -z "$TCLROOT"]) 
    679728AM_CONDITIONAL(HAVE_GUILE, [test ! -z "$GUILEROOT"]) 
     
    686735AM_CONDITIONAL(HAVE_XML, [test ! -z "$MXMLROOT"]) 
    687736AM_CONDITIONAL(HAVE_LIBXML2, [ test "$ac_cv_lib_xml2_xmlParseDocument" = "yes" ]) 
     737dnl AM_CONDITIONAL(HAVE_LIBMXMLPLUS, [ test "$ac_cv_lib_mxmlplus__ZN4MXML4NodeD2Ev" = "yes" ]) 
    688738AM_CONDITIONAL(HAVE_DOCBOOK, [test ! -z "$DOCBOOK2TXT" -a ! -z "$DOCBOOK2PDF"]) 
    689739AM_CONDITIONAL(HAVE_LATEX, [test ! -z "$LATEX"]) 
     
    730780                doc/Makefile 
    731781                doc/doxygen/Makefile 
    732                 doc/doxygen/Doxyfile 
    733782                doc/api/Makefile 
    734783                doc/nxdict/Makefile 
     
    747796                contrib/bindings/Makefile 
    748797                contrib/bindings/python/Makefile 
     798                macosx_install_kit/Makefile 
     799                macosx_install_kit/pkg.config 
    749800                scripts/Makefile 
    750801                scripts/nexus.pc:scripts/nexus_pc.in 
     
    782833JAVABINDING=`if test -n "$JAVAROOT" ; then echo yes ; else echo no ; fi`  
    783834IDLBINDING=`if test -n "$IDLROOT" ; then echo yes ; else echo no ; fi`  
    784 PYTHONBINDING=`if test -n "$PYTHONROOT" ; then echo yes; else echo no ; fi`  
     835PYTHONBINDING=`if test -n "$HAVE_PYTHON_FALSE"; then echo yes; else echo no ; fi`  
    785836if test -n "$SWIG" ; then  
    786837    SWIGBINDING="yes (" 
     
    817868                SWIG:          ${SWIGBINDING} 
    818869                 IDL:          ${IDLBINDING} (--with-idlroot=${IDLROOT}, --with-idldlm=${IDLDLM}) 
    819               PYTHON:          ${PYTHONBINDING} (PYTHONROOT=${PYTHONROOT}) 
     870              PYTHON:          ${PYTHONBINDING} (PYTHONROOT=${PYTHONROOT}, numpy found: $PYTHON_numpy_found) 
    820871 
    821872        documentation: 
  • tags/4.2.1/contrib/bindings/Makefile.am

    r1924 r1924  
    3434PYSUB = python 
    3535endif 
    36 SUBDIRS = $(JAVASUB) $(PYSUB) 
     36SUBDIRS = $(PYSUB) # $(JAVASUB) 
  • tags/4.2.1/doc

  • tags/4.2.1/doc/doxygen/Makefile.am

    r1924 r1924  
    1515if HAVE_PDFLATEX 
    1616if HAVE_DOT 
    17         rm -fr latex html 
    18         $(DOXYGEN) Doxyfile 
    19         ( cd latex; make pdf ) 
     17        rm -fr latex html latex-* html-* 
     18        env TOPSRC=$(top_srcdir) $(DOXYGEN) $(srcdir)/Doxyfile_c 
     19        ( cd latex-c; ) # ( cd latex-c; make pdf ) 
     20        env TOPSRC=$(top_srcdir) $(DOXYGEN) $(srcdir)/Doxyfile_cpp 
     21        ( cd latex-cpp; ) # ( cd latex-cpp; make pdf ) 
     22        env TOPSRC=$(top_srcdir) $(DOXYGEN) $(srcdir)/Doxyfile_java 
     23        ( cd latex-java; ) # ( cd latex-java; make pdf ) 
     24        env TOPSRC=$(top_srcdir) $(DOXYGEN) $(srcdir)/Doxyfile_python 
     25        ( cd latex-python; ) # ( cd latex-python; make pdf ) 
     26        env TOPSRC=$(top_srcdir) $(DOXYGEN) $(srcdir)/Doxyfile_f90 
     27        ( cd latex-f90; ) # ( cd latex-f90; make pdf ) 
     28        env TOPSRC=$(top_srcdir) $(DOXYGEN) $(srcdir)/Doxyfile_f77 
     29        ( cd latex-f77; ) # ( cd latex-f77; make pdf ) 
    2030        rm -f refman.pdf 
    21         ln -s latex/refman.pdf . 
     31        ln -s latex-c/refman.pdf . 
    2232endif 
    2333endif 
     
    2535        touch doxy.remove_me_to_remake 
    2636 
     37dist-hook : 
    2738if HAVE_DOXYGEN 
    2839if HAVE_PDFLATEX 
    2940if HAVE_DOT 
    30 dist-hook : 
    31         test -f $(srcdir)/refman.pdf && cp $(srcdir)/refman.pdf $(distdir) 
    32         if test -d $(srcdir)/html; then \ 
    33                 cp -r $(srcdir)/html $(distdir); \ 
    34                 find $(distdir)/html -depth -type d -name '.svn' -exec rm -fr {} \; ;\ 
     41        if test -f $(srcdir)/refman.pdf; then \ 
     42            cp $(srcdir)/refman.pdf $(distdir); \ 
    3543        fi 
    36  
    37 install-data-local : 
    38         $(mkinstalldirs) $(DESTDIR)$(nxdoxydir) 
    39         test -f $(srcdir)/refman.pdf && cp $(srcdir)/refman.pdf $(DESTDIR)$(nxdoxydir) 
    40         if test -d $(srcdir)/html; then \ 
    41                 cp -r $(srcdir)/html $(DESTDIR)$(nxdoxydir); \ 
    42                 find $(DESTDIR)$(nxdoxydir) -type f -exec chmod 0644 {} \; ;\ 
    43                 find $(DESTDIR)$(nxdoxydir) -type d -exec chmod 0755 {} \; ;\ 
     44        if test -d $(srcdir)/html-c; then \ 
     45          for i in $(srcdir)/html-*; do \ 
     46            if test -d $$i; then \ 
     47                cp -r $$i $(distdir); \ 
     48            fi; \ 
     49          done; \ 
     50          find $(distdir)/html-* -depth -type d -name '.svn' -exec rm -fr {} \; ; \ 
    4451        fi 
    4552endif 
     
    4754endif 
    4855 
     56install-data-local : 
     57        $(mkinstalldirs) $(DESTDIR)$(nxdoxydir) 
     58        if test -f $(srcdir)/refman.pdf; then \ 
     59            cp $(srcdir)/refman.pdf $(DESTDIR)$(nxdoxydir); \ 
     60        fi 
     61        if test -d $(srcdir)/html-c; then \ 
     62          for i in $(srcdir)/html-*; do \ 
     63                cp -r $$i $(DESTDIR)$(nxdoxydir); \ 
     64          done; \ 
     65          find $(DESTDIR)$(nxdoxydir) -type f -exec chmod 0644 {} \; ;\ 
     66          find $(DESTDIR)$(nxdoxydir) -type d -exec chmod 0755 {} \; ;\ 
     67        fi 
     68 
    4969clean-local : 
    50         rm -fr html latex refman.pdf 
     70        rm -fr html-* latex-* refman.pdf 
    5171 
    5272uninstall-local : 
    5373        rm -fr $(DESTDIR)$(nxdoxydir) 
    5474 
     75EXTRA_DIST=$(srcdir)/Doxyfile_* 
  • tags/4.2.1/doc/tech_ref/NeXus_definitions.docbook

    r1924 r1924  
    22 <!ENTITY terminology  SYSTEM "terminology.docbook"> 
    33 <!ENTITY methods      SYSTEM "methods.docbook"> 
    4  <!ENTITY base_classes SYSTEM "base_classes.docbook"> 
     4 <!ENTITY base-classes SYSTEM "base_classes.docbook"> 
    55 <!ENTITY monoref      SYSTEM "monoref.docbook"> 
    66 <!ENTITY monotas      SYSTEM "monotas.docbook"> 
     
    1010 <!ENTITY nxtranslate  "<application>NXtranslate</application>"> 
    1111 <!ENTITY napi         "<acronym>napi</acronym>"> 
    12  <!ENTITY mime_type    "<parameter>NXS:mime_type</parameter>"> 
     12 <!ENTITY mime-type    "<parameter>NXS:mime_type</parameter>"> 
    1313 <!ENTITY source       "<parameter>NXS:source</parameter>"> 
    1414 <!ENTITY location     "<parameter>NXS:location</parameter>"> 
    15  <!ENTITY make_link    "<parameter>target</parameter>"> 
    16  <!ENTITY link_tag     "<parameter>NAPIlink</parameter>"> 
     15 <!ENTITY make-link    "<parameter>target</parameter>"> 
     16 <!ENTITY link-tag     "<parameter>NAPIlink</parameter>"> 
    1717]> 
    1818  
     
    6161 
    6262<!-- ******************** BASE CLASSES ******************** --> 
    63 &base_classes 
     63&base-classes 
    6464 
    6565<!-- ******************** DEFINITIONS ******************** --> 
  • tags/4.2.1/doc/tech_ref/base_classes.docbook

    r1924 r1924  
    11<!-- ******************** BASE CLASSES ******************** --> 
    2 <chapter id="base_classes"><title>Base Classes</title> 
     2<chapter id="base-classes"><title>Base Classes</title> 
    33 
    44<para>This chapter will list all of the base classes and their 
     
    5959</example> 
    6060 
    61 <example id="NXbeam_stop.xml"><title><filename>NXbeam_stop.xml</filename></title> 
     61<example id="NXbeam-stop.xml"><title><filename>NXbeam_stop.xml</filename></title> 
    6262<programlisting role="XML"> 
    6363<![CDATA[<!-- 
     
    468468</example> 
    469469 
    470 <example id="NXdisk_chopper.xml"><title><filename>NXdisk_chopper.xml</filename></title> 
     470<example id="NXdisk-chopper.xml"><title><filename>NXdisk_chopper.xml</filename></title> 
    471471<programlisting role="XML"> 
    472472<![CDATA[<!-- 
     
    625625</example> 
    626626 
    627 <example id="NXevent_data.xml"><title><filename>NXevent_data.xml</filename></title> 
     627<example id="NXevent-data.xml"><title><filename>NXevent_data.xml</filename></title> 
    628628<programlisting role="XML"> 
    629629<![CDATA[<!-- 
     
    661661</example> 
    662662 
    663 <example id="NXfermi_chopper.xml"><title><filename>NXfermi_chopper.xml</filename></title> 
     663<example id="NXfermi-chopper.xml"><title><filename>NXfermi_chopper.xml</filename></title> 
    664664<programlisting role="XML"> 
    665665<![CDATA[<!-- 
     
    16161616</example> 
    16171617 
    1618 <example id="NXvelocity_selector.xml"><title><filename>NXvelocity_selector.xml</filename></title> 
     1618<example id="NXvelocity-selector.xml"><title><filename>NXvelocity_selector.xml</filename></title> 
    16191619<programlisting role="XML"> 
    16201620<![CDATA[<!-- 
  • tags/4.2.1/doc/tech_ref/methods.docbook

    r1924 r1924  
    3131definition.</para></listitem> 
    3232 
    33 <listitem id="method.ol.write_file"><para>Write a sample NeXus file 
     33<listitem id="method.ol.write-file"><para>Write a sample NeXus file 
    3434conforming to the instrument definition (for example, using 
    3535NXtranslate).</para></listitem> 
     
    3737<listitem id="method.ol.test"><para>Test the file, repeating steps 
    3838<xref linkend="method.ol.niac"> and <xref 
    39 linkend="method.ol.write_file"> as appropriate.</para></listitem> 
     39linkend="method.ol.write-file"> as appropriate.</para></listitem> 
    4040 
    4141<listitem id="method.ol.ratify"><para>Request ratification once the 
  • tags/4.2.1/doc/tech_ref/tofnpd.docbook

    r1924 r1924  
    4545</para> 
    4646 
    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> 
    4848<programlisting role="XML"> 
    4949<![CDATA[<!-- 
  • tags/4.2.1/examples

  • tags/4.2.1/include

  • tags/4.2.1/include/Makefile.am

    r1924 r1924  
    99include_HEADERS   = napi.h napiu.h 
    1010 
    11 noinst_HEADERS = napi4.h napi5.h nxxml.h napiconfig.h 
     11noinst_HEADERS = napi4.h napi5.h nxxml.h napiconfig.h nxconfig_vms.h 
  • tags/4.2.1/include/napi.h

    r1924 r1924  
    5050 
    5151/* NeXus HDF45 */ 
    52 #define NEXUS_VERSION   "4.2.0"                /* major.minor.patch */ 
     52#define NEXUS_VERSION   "4.2.1"                /* major.minor.patch */ 
    5353 
    5454#define CONSTCHAR       const char 
     
    180180#    define NXopengroup         MANGLE(nxiopengroup) 
    181181#    define NXopenpath          MANGLE(nxiopenpath) 
     182#    define NXgetpath           MANGLE(nxigetpath) 
    182183#    define NXopengrouppath     MANGLE(nxiopengrouppath) 
    183184#    define NXclosegroup        MANGLE(nxiclosegroup) 
     
    217218#    define NXisexternalgroup   MANGLE(nxiisexternalgroup) 
    218219#    define NXlinkexternal      MANGLE(nxilinkexternal) 
     220#    define NXgetversion        MANGLE(nxigetversion) 
    219221 
    220222/*  
     
    228230#    define NXfcompress         MANGLE(nxifcompress) 
    229231#    define NXfputattr          MANGLE(nxifputattr) 
    230  
     232#    define NXfgetpath          MANGLE(nxifgetpath) 
    231233 
    232234/*  
     
    324326   */ 
    325327extern  NXstatus  NXopengrouppath (NXhandle handle, CONSTCHAR *path); 
     328  /** 
     329   * Retrieve the current path in the NeXus file 
     330   * \param handle a NeXus file handle 
     331   * \param path A buffer to copy the path too 
     332   * \parm  pathlen The maximum number of characters to copy into path 
     333   * \return NX_OK or NX_ERROR 
     334   */ 
     335extern NXstatus NXgetpath(NXhandle handle, char *path, int pathlen); 
    326336 
    327337  /** 
     
    674684 
    675685  /** 
     686   * Utility function to return NeXus version 
     687   * \return pointer to string in static storage. Version in 
     688   * same format as NEXUS_VERSION string in napi.h i.e. "major.minor.patch" 
     689   * \ingroup c_metadata 
     690   */ 
     691extern  const char* NXgetversion(); 
     692 
     693  /** 
    676694   * Utility function to release the memory for data. 
    677695   * \param data A pointer to a pointer to free. 
     
    710728 
    711729  /** 
    712    * Set an error function. 
    713    * \param pData A pointer to a user defined data structure which be passed opaquely to  
     730   * Set a global error function. 
     731   * Not threadsafe. 
     732   * \param pData A pointer to a user defined data structure which be passed to  
    714733   * the error display function. 
    715734   * \param newErr The new error display function. 
     
    718737 
    719738  /** 
     739   * Set an error function for the current thread. 
     740   * When used this overrides anything set in NXMSetError (for the current thread). 
     741   * Use this method in threaded applications. 
     742   * \param pData A pointer to a user defined data structure which be passed to  
     743   * the error display function. 
     744   * \param newErr The new error display function. 
     745   */ 
     746extern  void  NXMSetTError(void *pData, ErrFunc newErr); 
     747 
     748  /** 
    720749   * Retrieve the current error display function 
    721    * \return The current erro display function. 
     750   * \return The current error display function. 
    722751   */ 
    723752extern ErrFunc NXMGetError(); 
     
    734763 
    735764 
    736 extern void (*NXIReportError)(void *pData,char *text); 
     765extern void NXIReportError(void *pData,char *text); 
    737766extern void *NXpData; 
    738767extern char *NXIformatNeXusTime(); 
     
    784813 
    785814  extern NXstatus  NXfopen(char * filename, NXaccess* am,  
    786                                         NexusFunction* pHandle); 
    787   extern NXstatus  NXfclose (NexusFunction* pHandle); 
     815                                        NXhandle pHandle); 
     816  extern NXstatus  NXfclose (NXhandle pHandle); 
    788817  extern NXstatus  NXfputattr(NXhandle fid, char *name, void *data,  
    789818                                   int *pDatalen, int *pIType); 
     
    795824  extern NXstatus  NXfmakedata(NXhandle fid, char *name, int *pDatatype, 
    796825                int *pRank, int dimensions[]); 
    797   extern NXstatus  NXfflush(NexusFunction* pHandle); 
    798  
     826  extern NXstatus  NXfflush(NXhandle pHandle); 
     827  extern NXstatus  NXfgetpath(NXhandle fid, char *path, int *pathlen); 
    799828#ifdef __cplusplus 
    800829} 
    801830#endif /* __cplusplus */ 
    802831 
     832/** 
     833 * Freddie Akeroyd 11/8/2009 
     834 * Add NeXus schema support - this uses BASE.xsd as the initial file 
     835 */ 
     836#define NEXUS_SCHEMA_VERSION    "3.1"   /**< version of NeXus definition schema */ 
     837#define NEXUS_SCHEMA_ROOT       "http://definition.nexusformat.org/schema/"     /**< XML schema namespace specified by xmlns */ 
     838#define NEXUS_SCHEMA_NAMESPACE  NEXUS_SCHEMA_ROOT NEXUS_SCHEMA_VERSION  /**< XML schema namespace specified by xmlns */ 
     839#define NEXUS_SCHEMA_BASE       "BASE" 
     840#define NEXUS_SCHEMA_FILE       NEXUS_SCHEMA_BASE ".xsd" /**< default schema file for namespace */ 
     841#define NEXUS_SCHEMA_URL        NEXUS_SCHEMA_NAMESPACE "/" NEXUS_SCHEMA_FILE /**< location of default schema file for namespace */ 
     842 
    803843#endif /*NEXUSAPI*/ 
    804  
  • tags/4.2.1/include/napiconfig.h

    r1924 r1924  
    66#endif /* _WIN32 */ 
    77 
     8#ifdef __VMS 
     9#include <nxconfig_vms.h> 
     10#else 
    811#include <nxconfig.h> 
     12#endif /* __VMS */ 
     13 
    914 
    1015/* 
     
    1621#if HAVE_STDINT_H 
    1722#include <stdint.h> 
     23#elif HAVE_INTTYPES_H 
     24#include <inttypes.h> 
    1825#endif /* HAVE_STDINT_H */ 
    1926 
  • tags/4.2.1/nexus_spec.in

    r1924 r1924  
    7171%{_datadir}/* 
    7272%{_includedir}/* 
     73/usr/lib/python*/site-packages/nxs 
    7374#%files devel 
    7475#%{_libdir}/*.a 
  • tags/4.2.1/scripts

  • tags/4.2.1/src/Makefile.am

    r1924 r1924  
    3030 
    3131AM_CPPFLAGS=-I$(top_srcdir)/include @HDF4_CPPFLAGS@ @HDF5_CPPFLAGS@ @XML_CPPFLAGS@ -DIN_NEXUS_LIBRARY 
     32AM_LDFLAGS=-version-info $(NXLTVERSINFO) 
    3233AM_CFLAGS=-prefer-pic 
    3334 
     
    7677#SUBDIRS=nxdict 
    7778 
    78 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) 
     79libNeXus_la_SOURCES = napi.c napiu.c nxstack.c nxstack.h stptok.c  nxdataset.c nxdataset.h nx_stptok.h $(H4SRC) $(H5SRC) $(XMLSRC) $(MINGW_SRC) 
    7980libNeXus_la_LDFLAGS = -export-symbols nexus_symbols.sym @SHARED_LDFLAGS@ @HDF4_LDFLAGS@ @HDF5_LDFLAGS@ @XML_LDFLAGS@ $(LDFLAGS) 
    8081libNeXus_la_DEPENDENCIES = nexus_symbols.sym 
  • tags/4.2.1/src/napi.c

    r1924 r1924  
    178178  static void NXNXNXReportError(void *pData, char *string) 
    179179  { 
    180     printf("%s \n",string); 
     180    fprintf(stderr, "%s \n", string); 
    181181  } 
    182182  /*---------------------------------------------------------------------*/ 
     183 
    183184  void *NXpData = NULL; 
    184   void (*NXIReportError)(void *pData, char *string) = NXNXNXReportError; 
     185  void *NXEHpData = NULL; 
     186  void (*NXEHIReportError)(void *pData, char *string) = NXNXNXReportError; 
     187#ifdef HAVE_TLS 
     188  __thread void *NXEHpTData = NULL; 
     189  __thread void (*NXEHIReportTError)(void *pData, char *string) = NULL; 
     190#endif 
     191 
     192  void NXIReportError(void *pData, char *string) { 
     193#ifdef HAVE_TLS 
     194        if (NXEHIReportTError) { 
     195                (*NXEHIReportTError)(NXEHpTData, string); 
     196                return; 
     197        }  
     198#endif 
     199 
     200        (*NXEHIReportError)(NXEHpData, string); 
     201  } 
     202 
    185203  /*---------------------------------------------------------------------*/ 
    186   extern void NXMSetError(void *pData,  
    187                               void (*NewError)(void *pD, char *text)) 
    188   { 
    189     NXpData = pData; 
    190     NXIReportError = NewError; 
     204  extern void NXMSetError(void *pData, void (*NewError)(void *pD, char *text)) 
     205  { 
     206    NXEHpData = pData; 
     207    NXEHIReportError = NewError; 
     208  } 
     209/*----------------------------------------------------------------------*/ 
     210  extern void NXMSetTError(void *pData, void (*NewError)(void *pD, char *text)) 
     211  { 
     212#ifdef HAVE_TLS 
     213    NXEHpTData = pData; 
     214    NXEHIReportTError = NewError; 
     215#else 
     216    NXMSetError(pData, NewError); 
     217#endif 
    191218  } 
    192219/*----------------------------------------------------------------------*/ 
    193220extern ErrFunc NXMGetError(){ 
    194   return NXIReportError; 
     221#ifdef HAVE_TLS 
     222        if (NXEHIReportTError) { 
     223                return NXEHIReportTError; 
     224        } 
     225#endif 
     226  return NXEHIReportError; 
    195227} 
    196228 
     
    201233/*----------------------------------------------------------------------*/ 
    202234 
    203 static ErrFunc last_errfunc = NXNXNXReportError; 
     235ErrFunc last_global_errfunc = NXNXNXReportError; 
     236#ifdef HAVE_TLS 
     237__thread ErrFunc last_thread_errfunc = NULL; 
     238#endif 
    204239 
    205240extern void NXMDisableErrorReporting() 
    206241{ 
    207     last_errfunc = NXMGetError(); 
    208     NXMSetError(NXpData, NXNXNoReport); 
     242#ifdef HAVE_TLS 
     243        if (NXEHIReportTError) { 
     244                last_thread_errfunc = NXEHIReportTError; 
     245                NXEHIReportTError = NXNXNoReport; 
     246                return; 
     247        }  
     248        last_thread_errfunc = NULL; 
     249#endif 
     250        last_global_errfunc = NXEHIReportError; 
     251        NXEHIReportError = NXNXNoReport; 
    209252} 
    210253 
    211254extern void NXMEnableErrorReporting() 
    212255{ 
    213     NXMSetError(NXpData, last_errfunc); 
     256#ifdef HAVE_TLS 
     257        if (last_thread_errfunc) { 
     258                NXEHIReportTError = last_thread_errfunc; 
     259                last_thread_errfunc = NULL; 
     260                return; 
     261        }  
     262#endif 
     263        NXEHIReportError = last_global_errfunc; 
    214264} 
    215265 
     
    232282{ 
    233283  FILE *fd = NULL; 
    234   int iRet, fapl; 
    235   NXhandle handle; 
     284  int iRet; 
    236285   
    237286  /* 
     
    283332  int status; 
    284333  pFileStack fileStack = NULL; 
    285   NXhandle hfile; 
    286334 
    287335  *gHandle = NULL; 
     
    538586    pFileStack fileStack;     
    539587    char nxurl[1024], exfile[512], expath[512]; 
    540     ErrFunc oldError; 
    541588    pNexusFunction pFunc = NULL; 
    542589 
     
    545592 
    546593    status = pFunc->nxopengroup(pFunc->pNexusData, name, nxclass);   
    547     oldError = NXMGetError(); 
    548     NXIReportError = NXNXNoReport; 
     594    if(status == NX_OK){ 
     595      pushPath(fileStack,name); 
     596    } 
     597    NXMDisableErrorReporting(); 
    549598    attStatus = NXgetattr(fid,"napimount",nxurl,&length, &type); 
    550     NXIReportError = oldError; 
     599    NXMEnableErrorReporting(); 
    551600    if(attStatus == NX_OK){ 
    552601      /* 
     
    580629    fileStack = (pFileStack)fid; 
    581630    if(fileStackDepth(fileStack) == 0){ 
    582       return pFunc->nxclosegroup(pFunc->pNexusData);   
     631      status = pFunc->nxclosegroup(pFunc->pNexusData);   
     632      if(status == NX_OK){ 
     633        popPath(fileStack); 
     634      } 
     635      return status; 
    583636    } else { 
    584637      /* we have to check for leaving an external file */ 
     
    590643      } else { 
    591644        status = pFunc->nxclosegroup(pFunc->pNexusData); 
     645        if(status == NX_OK){ 
     646          popPath(fileStack); 
     647        } 
    592648      } 
    593649      return status; 
     
    628684  NXstatus  NXopendata (NXhandle fid, CONSTCHAR *name) 
    629685  { 
     686    int status; 
     687    pFileStack fileStack = NULL; 
     688 
    630689    pNexusFunction pFunc = handleToNexusFunc(fid);  
    631     return pFunc->nxopendata(pFunc->pNexusData, name);  
     690    fileStack = (pFileStack)fid; 
     691    status = pFunc->nxopendata(pFunc->pNexusData, name);  
     692    if(status == NX_OK){ 
     693      pushPath(fileStack,name); 
     694    } 
     695    return status; 
    632696  }  
    633697 
     
    637701  NXstatus  NXclosedata (NXhandle fid) 
    638702  {  
    639     pNexusFunction pFunc = handleToNexusFunc(fid); 
    640     return pFunc->nxclosedata(pFunc->pNexusData); 
     703    int status; 
     704    pFileStack fileStack = NULL; 
     705 
     706    pNexusFunction pFunc = handleToNexusFunc(fid); 
     707    fileStack = (pFileStack)fid; 
     708    status = pFunc->nxclosedata(pFunc->pNexusData); 
     709    if(status == NX_OK){ 
     710      popPath(fileStack); 
     711    } 
     712    return status; 
    641713  } 
    642714 
     
    10261098    return status; 
    10271099  } 
    1028   oldError = NXMGetError(); 
    1029   NXIReportError = NXNXNoReport; 
     1100  NXMDisableErrorReporting(); 
    10301101  attStatus = NXgetattr(fid,"napimount",nxurl,&length, &type); 
    1031   NXIReportError = oldError; 
     1102  NXMEnableErrorReporting(); 
    10321103  pFunc->nxclosegroup(pFunc->pNexusData); 
    10331104  if(attStatus == NX_OK){ 
     
    10621133} 
    10631134/*------------------------------------------------------------------------ 
    1064   Implementation of NXopenpath.  
     1135  Implementation of NXopenpath  
    10651136  --------------------------------------------------------------------------*/ 
    10661137static int isDataSetOpen(NXhandle hfil) 
     
    11851256{ 
    11861257  int status; 
    1187   NXname pathElem; 
    11881258  char *pPtr; 
    11891259 
     
    12141284static NXstatus stepOneUp(NXhandle hfil, char *name) 
    12151285{ 
    1216   int status, datatype; 
     1286  int datatype; 
    12171287  NXname name2, xclass; 
    12181288  char pBueffel[256];   
     
    12501320static NXstatus stepOneGroupUp(NXhandle hfil, char *name) 
    12511321{ 
    1252   int status, datatype; 
     1322  int datatype; 
    12531323  NXname name2, xclass; 
    12541324  char pBueffel[256];   
     
    13571427  return NX_OK; 
    13581428} 
    1359  
     1429/*---------------------------------------------------------------------*/ 
    13601430NXstatus NXIprintlink(NXhandle fid, NXlink* link) 
    13611431{ 
    13621432     pNexusFunction pFunc = handleToNexusFunc(fid); 
    13631433     return pFunc->nxprintlink(pFunc->pNexusData, link);    
     1434} 
     1435/*----------------------------------------------------------------------*/ 
     1436NXstatus NXgetpath(NXhandle fid, char *path, int pathlen){ 
     1437  int status; 
     1438  pFileStack fileStack = NULL; 
     1439 
     1440  fileStack = (pFileStack)fid; 
     1441  status = buildPath(fileStack,path,pathlen); 
     1442  if(status != 1){ 
     1443    return NX_ERROR; 
     1444  }  
     1445  return NX_OK; 
    13641446} 
    13651447 
     
    13681450  ---------------------------------------------------------------------*/ 
    13691451char *NXIformatNeXusTime(){ 
    1370     char *timeData; 
    13711452    time_t timer; 
    13721453    char* time_buffer = NULL; 
     
    14461527   */ 
    14471528  NXstatus  NXfopen(char * filename, NXaccess* am,  
    1448                                  NexusFunction* pHandle) 
     1529                                 NXhandle pHandle) 
    14491530  { 
    14501531        NXstatus ret; 
     
    14531534        if (ret == NX_OK) 
    14541535        { 
    1455             memcpy(pHandle, fileid, sizeof(NexusFunction)); 
     1536          memcpy(pHandle, fileid, getFileStackSize()); 
    14561537        } 
    14571538        else 
    14581539        { 
    1459             memset(pHandle, 0, sizeof(NexusFunction)); 
     1540          memset(pHandle, 0, getFileStackSize()); 
    14601541        } 
    14611542        if (fileid != NULL) 
     
    14701551 * a temporary copy as NXclose will try to free() this 
    14711552 */ 
    1472   NXstatus  NXfclose (NexusFunction* pHandle) 
     1553  NXstatus  NXfclose (NXhandle pHandle) 
    14731554  { 
    14741555    NXhandle h; 
    14751556    NXstatus ret; 
    1476     h = (NXhandle)malloc(sizeof(NexusFunction)); 
    1477     memcpy(h, pHandle, sizeof(NexusFunction)); 
     1557    h = (NXhandle)malloc(getFileStackSize()); 
     1558    memcpy(h, pHandle, getFileStackSize()); 
    14781559    ret = NXclose(&h);          /* does free(h) */ 
    1479     memset(pHandle, 0, sizeof(NexusFunction)); 
     1560    memset(pHandle, 0, getFileStackSize()); 
    14801561    return ret; 
    14811562  } 
    14821563   
    14831564/*---------------------------------------------------------------------*/   
    1484   NXstatus  NXfflush(NexusFunction* pHandle) 
     1565  NXstatus  NXfflush(NXhandle pHandle) 
    14851566  { 
    14861567    NXhandle h; 
    14871568    NXstatus ret; 
    1488     h = (NXhandle)malloc(sizeof(NexusFunction)); 
    1489     memcpy(h, pHandle, sizeof(NexusFunction)); 
     1569    h = (NXhandle)malloc(getFileStackSize()); 
     1570    memcpy(h, pHandle, getFileStackSize()); 
    14901571    ret = NXflush(&h);          /* modifies and reallocates h */ 
    1491     memcpy(pHandle, h, sizeof(NexusFunction)); 
     1572    memcpy(pHandle, h, getFileStackSize()); 
    14921573    return ret; 
    14931574  } 
     
    15201601  } 
    15211602 
    1522  
     1603/*-----------------------------------------------------------------------*/ 
    15231604  NXstatus  NXfcompmakedata(NXhandle fid, char *name,  
    15241605                int *pDatatype, 
     
    15791660  } 
    15801661 
     1662/*--------------------------------------------------------------------------*/ 
     1663NXstatus NXfgetpath(NXhandle fid, char *path, int *pathlen) 
     1664{ 
     1665  return NXgetpath(fid,path,*pathlen); 
     1666} 
     1667 
     1668const char* NXgetversion() 
     1669{ 
     1670    return NEXUS_VERSION ; 
     1671} 
  • tags/4.2.1/src/napi4.c

    r1924 r1924  
    2525 
    2626----------------------------------------------------------------------------*/ 
     27 
     28#ifdef HDF4  
     29 
    2730#include <stdlib.h> 
    2831#include <assert.h> 
     
    110113  { 
    111114    int32 iNew, iRef, iTag; 
    112     int iN, i, status; 
     115    int iN, i; 
    113116    int32 *pArray = NULL; 
    114117    NXname pText; 
     
    12891292  { 
    12901293    pNexusFile pFile; 
    1291     ErrFunc oldErr; 
    12921294    int datalen, type = NX_CHAR; 
    12931295 
     
    13001302      sRes->iTag = DFTAG_NDG; 
    13011303      sRes->iRef = SDidtoref (pFile->iCurrentSDS); 
    1302       oldErr = NXMGetError(); 
    1303       NXMSetError(NXpData, ignoreError); 
     1304      NXMDisableErrorReporting(); 
    13041305      datalen = 1024; 
    13051306      memset(&sRes->targetPath,0,1024); 
     
    13081309        NXIbuildPath(pFile,sRes->targetPath,1024); 
    13091310      } 
    1310       NXMSetError(NXpData,oldErr); 
     1311      NXMEnableErrorReporting(); 
    13111312      return NX_OK; 
    13121313    } 
     
    13221323  { 
    13231324    pNexusFile pFile; 
    1324     int32 iVG, iRet, dataID, type = DFNT_CHAR8, length; 
     1325    int32 dataID, type = DFNT_CHAR8, length; 
    13251326    char name[] = "target"; 
    13261327   
     
    13541355  { 
    13551356    pNexusFile pFile; 
    1356     int32 iVG, iRet, dataID, type = DFNT_CHAR8, length, dataType = NX_CHAR,  
     1357    int32 dataID, type = DFNT_CHAR8, length, dataType = NX_CHAR,  
    13571358      rank = 1, attType = NX_INT32; 
    13581359    int iDim[1]; 
     
    18131814    *iType = (int)iType32; 
    18141815    iLen = iLen * DFKNTsize (*iType); 
     1816    if(*iType == NX_CHAR){ 
     1817      iLen += 1; 
     1818    } 
    18151819    pData = (void *) malloc (iLen); 
    18161820    if (!pData) { 
     
    20062010      fHandle->nxprintlink=NX4printlink; 
    20072011} 
     2012 
     2013#endif /*HDF4*/ 
  • tags/4.2.1/src/napi5.c

    r1924 r1924  
    2323 
    2424----------------------------------------------------------------------------*/ 
     25 
     26#ifdef HDF5  
     27 
    2528#include <stdlib.h> 
    2629#include <assert.h> 
     
    9497static void buildCurrentPath(pNexusFile5 self, char *pathBuffer,  
    9598                             int pathBufferLen){ 
    96   int length; 
    9799 
    98100  memset(pathBuffer,0,pathBufferLen); 
     
    773775  pNexusFile5 pFile; 
    774776  int chunk_size[H5S_MAX_RANK]; 
    775   int i; 
    776    
     777    
    777778  pFile = NXI5assert (fid); 
    778779  memset(chunk_size,0,H5S_MAX_RANK*sizeof(int)); 
    779   if (dimensions[0] == NX_UNLIMITED) 
    780      { 
    781      for (i = 0; i < H5S_MAX_RANK; i++) 
    782        { 
    783          chunk_size[i]= 1; 
    784        }  
    785      }     
     780  memcpy(chunk_size,dimensions,rank*sizeof(int)); 
     781  if (dimensions[0] == NX_UNLIMITED){ 
     782         chunk_size[0]= 1; 
     783  }     
    786784  return NX5compmakedata (fid, name, datatype, rank, dimensions, NX_COMP_NONE, chunk_size); 
    787785     
     
    10521050  { 
    10531051    pNexusFile5 pFile; 
    1054     ErrFunc oldErr; 
    10551052    int datalen, type = NX_CHAR; 
    10561053   
     
    10681065      the path to the current node 
    10691066    */ 
    1070     oldErr = NXMGetError(); 
    1071     NXMSetError(NXpData, ignoreError); 
     1067    NXMDisableErrorReporting(); 
    10721068    datalen = 1024; 
    10731069    memset(&sRes->targetPath,0,datalen*sizeof(char)); 
     
    10761072      buildCurrentPath(pFile, sRes->targetPath, 1024); 
    10771073    } 
    1078     NXMSetError(NXpData,oldErr); 
     1074    NXMEnableErrorReporting(); 
    10791075    sRes->linkType = 1; 
    10801076    return NX_OK; 
     
    11461142    pNexusFile5 pFile; 
    11471143    char linkTarget[1024]; 
    1148     int type = NX_CHAR, length; 
     1144    int type = NX_CHAR; 
    11491145    int status; 
    11501146 
     
    11811177    pNexusFile5 pFile; 
    11821178    char linkTarget[1024]; 
    1183     int type = NX_CHAR, length; 
     1179    int type = NX_CHAR; 
    11841180    char *itemName = NULL; 
    11851181    int status; 
     
    12821278  herr_t group_info1(hid_t loc_id, const char *name, void *opdata) 
    12831279  { 
    1284     NexusFile5 self; 
    12851280    H5G_stat_t statbuf; 
    1286     self.iNX = *((int*)opdata); 
     1281    int iNX = *((int*)opdata); 
    12871282    H5Gget_objinfo(loc_id, name, 0, &statbuf); 
    12881283     
     
    12901285    { 
    12911286      case H5G_GROUP:  
    1292         self.iNX++; 
    1293         *((int*)opdata)=self.iNX; 
     1287        iNX++; 
     1288        *((int*)opdata)=iNX; 
    12941289        break; 
    12951290      case H5G_DATASET: 
    1296         self.iNX++; 
    1297         *((int*)opdata)=self.iNX; 
     1291        iNX++; 
     1292        *((int*)opdata)=iNX; 
    12981293        break; 
    12991294      default: 
     
    13051300  /*-------------------------------------------------------------------------*/ 
    13061301 
    1307   NXstatus  NX5getgroupinfo (NXhandle fid, int *iN, NXname pName, NXname pClass) 
     1302  NXstatus  NX5getgroupinfo_recurse (NXhandle fid, int *iN, NXname pName, NXname pClass) 
    13081303  { 
    13091304    pNexusFile5 pFile; 
     
    13391334    return NX_OK; 
    13401335  } 
    1341  
    1342 /*------------------------------------------------------------------------*/ 
    1343 static int hdf5ToNXType(int data_id, hid_t atype) 
     1336/*---------------------------------------------------------------------------*/ 
     1337static int countObjectsInGroup(hid_t loc_id) 
    13441338{ 
    1345   int iPtype = -1; 
    1346   hid_t sign_id, size_id; 
    1347  
    1348            if (data_id==H5T_STRING) 
    1349            { 
    1350              iPtype=NX_CHAR; 
    1351            } 
    1352            if (data_id==H5T_INTEGER) 
     1339  int count = 0, type; 
     1340  hsize_t numobj, i; 
     1341   
     1342  herr_t status; 
     1343 
     1344  status = H5Gget_num_objs(loc_id, &numobj); 
     1345  if(status < 0) { 
     1346    NXIReportError(NXpData,"Internal error, failed to retrive no of objects"); 
     1347    return 0; 
     1348  } 
     1349 
     1350  for(i = 0; i < numobj; i++){ 
     1351    type = H5Gget_objtype_by_idx(loc_id,i); 
     1352    if(type == H5G_GROUP || type == H5G_DATASET){ 
     1353      count++; 
     1354    } 
     1355  } 
     1356  return count; 
     1357} 
     1358/*----------------------------------------------------------------------------*/ 
     1359  NXstatus  NX5getgroupinfo (NXhandle fid, int *iN, NXname pName, NXname pClass) 
     1360  { 
     1361    pNexusFile5 pFile; 
     1362    hid_t atype, attr_id, gid; 
     1363    char data[64]; 
     1364    int iRet; 
     1365         
     1366    pFile = NXI5assert (fid); 
     1367    /* check if there is a group open */ 
     1368    if (pFile->iCurrentG == 0) { 
     1369       strcpy (pName, "root"); 
     1370       strcpy (pClass, "NXroot"); 
     1371       gid = H5Gopen(pFile->iFID,"/"); 
     1372       *iN = countObjectsInGroup(gid); 
     1373       H5Gclose(gid); 
     1374    } 
     1375    else { 
     1376      strcpy (pName,pFile->name_ref); 
     1377      attr_id = H5Aopen_name(pFile->iCurrentG,"NX_class"); 
     1378      if (attr_id<0) { 
     1379         strcpy(pClass, NX_UNKNOWN_GROUP); 
     1380      } else { 
     1381        atype=H5Tcopy(H5T_C_S1); 
     1382        H5Tset_size(atype,sizeof(data));   
     1383        H5Aread(attr_id, atype, data); 
     1384        strcpy(pClass,data); 
     1385        pFile->iNX=0; 
     1386        *iN = countObjectsInGroup(pFile->iCurrentG); 
     1387        H5Aclose(attr_id); 
     1388      } 
     1389    } 
     1390    return NX_OK; 
     1391  } 
     1392 
     1393 
     1394/*------------------------------------------------------------------------- 
     1395 * Function: hdf5ToNXType 
     1396 * 
     1397 * Purpose:     Convert a HDF5 class to a NeXus "type";  it handles the following HDF5 classes 
     1398 *  H5T_STRING 
     1399 *  H5T_INTEGER 
     1400 *  H5T_FLOAT 
     1401 * 
     1402 * Return: the NeXus "type"  
     1403 * 
     1404 *------------------------------------------------------------------------- 
     1405 */ 
     1406  static int hdf5ToNXType(H5T_class_t tclass, hid_t atype) 
     1407  { 
     1408      int        iPtype = -1; 
     1409      size_t     size_id; 
     1410      H5T_sign_t sign_id; 
     1411 
     1412      if (tclass==H5T_STRING) 
     1413      { 
     1414          iPtype=NX_CHAR; 
     1415      } 
     1416      else if (tclass==H5T_INTEGER) 
     1417      { 
     1418          size_id=H5Tget_size(atype); 
     1419          sign_id=H5Tget_sign(atype); 
     1420          if (size_id==1) 
    13531421          { 
    1354              size_id=H5Tget_size(atype); 
    1355              sign_id=H5Tget_sign(atype); 
    1356              if (size_id==1) 
    1357              { 
    1358                 if (sign_id==H5T_SGN_2) 
    1359                 { 
    1360                    iPtype=NX_INT8; 
    1361                 } else { 
    1362                    iPtype=NX_UINT8; 
    1363                 } 
    1364              }  
    1365              else if (size_id==2)  
    1366              { 
    1367                 if (sign_id==H5T_SGN_2) 
    1368                 { 
    1369                    iPtype=NX_INT16; 
    1370                 } else { 
    1371                    iPtype=NX_UINT16; 
    1372                 } 
    1373              } 
    1374              else if (size_id==4)  
    1375              { 
    1376                  if (sign_id==H5T_SGN_2) 
    1377                  { 
    1378                     iPtype=NX_INT32; 
    1379                  } else { 
    1380                     iPtype=NX_UINT32; 
    1381                  } 
    1382              }  
    1383              else if(size_id == 8) 
    1384              { 
    1385                  if (sign_id==H5T_SGN_2) 
    1386                  { 
    1387                     iPtype=NX_INT64; 
    1388                  } else { 
    1389                     iPtype=NX_UINT64; 
    1390                  } 
    1391              } 
    1392         } else if (data_id==H5T_FLOAT)      
    1393             { 
    1394             size_id=H5Tget_size(atype); 
    1395             if (size_id==4) 
    1396             { 
    1397                iPtype=NX_FLOAT32; 
    1398             }  
    1399             else if (size_id==8)  
    1400             { 
    1401                iPtype=NX_FLOAT64; 
    1402             } 
    1403         } 
    1404         if (iPtype == -1) 
    1405         { 
    1406          NXIReportError (NXpData, "ERROR: hdf5ToNXtype: invalid type"); 
    1407         } 
    1408  
    1409            return iPtype; 
    1410 } 
     1422              if (sign_id==H5T_SGN_2) 
     1423              { 
     1424                  iPtype=NX_INT8; 
     1425              } else { 
     1426                  iPtype=NX_UINT8; 
     1427              } 
     1428          }  
     1429          else if (size_id==2)  
     1430          { 
     1431              if (sign_id==H5T_SGN_2) 
     1432              { 
     1433                  iPtype=NX_INT16; 
     1434              } else { 
     1435                  iPtype=NX_UINT16; 
     1436              } 
     1437          } 
     1438          else if (size_id==4)  
     1439          { 
     1440              if (sign_id==H5T_SGN_2) 
     1441              { 
     1442                  iPtype=NX_INT32; 
     1443              } else { 
     1444                  iPtype=NX_UINT32; 
     1445              } 
     1446          }  
     1447          else if(size_id == 8) 
     1448          { 
     1449              if (sign_id==H5T_SGN_2) 
     1450              { 
     1451                  iPtype=NX_INT64; 
     1452              } else { 
     1453                  iPtype=NX_UINT64; 
     1454              } 
     1455          } 
     1456      }  
     1457      else if (tclass==H5T_FLOAT)      
     1458      { 
     1459          size_id=H5Tget_size(atype); 
     1460          if (size_id==4) 
     1461          { 
     1462              iPtype=NX_FLOAT32; 
     1463          }  
     1464          else if (size_id==8)  
     1465          { 
     1466              iPtype=NX_FLOAT64; 
     1467          } 
     1468      } 
     1469      if (iPtype == -1) 
     1470      { 
     1471          NXIReportError (NXpData, "ERROR: hdf5ToNXtype: invalid type"); 
     1472      } 
     1473 
     1474      return iPtype; 
     1475  } 
    14111476/*--------------------------------------------------------------------------*/ 
    1412 static int h5MemType(hid_t atype) 
    1413 { 
    1414   hid_t data_id, size_id, sign_id, memtype_id = -1; 
    1415   
    1416   data_id = H5Tget_class(atype); 
    1417  
    1418        if (data_id==H5T_INTEGER) 
    1419      { 
    1420         size_id=H5Tget_size(atype); 
    1421         sign_id=H5Tget_sign(atype); 
    1422         if (size_id==1) 
    1423         { 
    1424             if (sign_id==H5T_SGN_2) 
    1425             { 
    1426                memtype_id = H5T_NATIVE_INT8; 
    1427             } else { 
    1428                memtype_id = H5T_NATIVE_UINT8; 
    1429             } 
    1430         }  
    1431         else if (size_id==2)  
    1432         { 
    1433            if (sign_id==H5T_SGN_2) 
    1434            { 
    1435               memtype_id = H5T_NATIVE_INT16; 
    1436            } else { 
    1437               memtype_id = H5T_NATIVE_UINT16;  
    1438            } 
    1439         } 
    1440         else if (size_id==4)  
    1441         { 
    1442           if (sign_id==H5T_SGN_2) 
    1443           { 
    1444              memtype_id = H5T_NATIVE_INT32; 
    1445           } else { 
    1446              memtype_id = H5T_NATIVE_UINT32;  
    1447           } 
    1448         } 
    1449         else if (size_id==8)  
    1450         { 
    1451           if (sign_id==H5T_SGN_2) 
    1452           { 
    1453             memtype_id = H5T_NATIVE_INT64; 
    1454           } else { 
    1455             memtype_id = H5T_NATIVE_UINT64; 
    1456           } 
    1457         } 
     1477  static int h5MemType(hid_t atype) 
     1478  { 
     1479      hid_t memtype_id = -1; 
     1480      size_t size_id; 
     1481      H5T_sign_t sign_id; 
     1482      H5T_class_t data_id; 
     1483 
     1484      data_id = H5Tget_class(atype); 
     1485 
     1486      if (data_id==H5T_INTEGER) 
     1487      { 
     1488          size_id=H5Tget_size(atype); 
     1489          sign_id=H5Tget_sign(atype); 
     1490          if (size_id==1) 
     1491          { 
     1492              if (sign_id==H5T_SGN_2) 
     1493              { 
     1494                  memtype_id = H5T_NATIVE_INT8; 
     1495              } else { 
     1496                  memtype_id = H5T_NATIVE_UINT8; 
     1497              } 
     1498          }  
     1499          else if (size_id==2)  
     1500          { 
     1501              if (sign_id==H5T_SGN_2) 
     1502              { 
     1503                  memtype_id = H5T_NATIVE_INT16; 
     1504              } else { 
     1505                  memtype_id = H5T_NATIVE_UINT16;  
     1506              } 
     1507          } 
     1508          else if (size_id==4)  
     1509          { 
     1510              if (sign_id==H5T_SGN_2) 
     1511              { 
     1512                  memtype_id = H5T_NATIVE_INT32; 
     1513              } else { 
     1514                  memtype_id = H5T_NATIVE_UINT32;  
     1515              } 
     1516          } 
     1517          else if (size_id==8)  
     1518          { 
     1519              if (sign_id==H5T_SGN_2) 
     1520              { 
     1521                  memtype_id = H5T_NATIVE_INT64; 
     1522              } else { 
     1523                  memtype_id = H5T_NATIVE_UINT64; 
     1524              } 
     1525          } 
    14581526      } else if (data_id==H5T_FLOAT)      
    1459         { 
    1460           size_id=H5Tget_size(atype); 
    1461           if (size_id==4) 
    1462           { 
    1463              memtype_id = H5T_NATIVE_FLOAT;  
    1464           } else if (size_id==8) { 
    1465              memtype_id = H5T_NATIVE_DOUBLE; 
    1466           } 
     1527      { 
     1528          size_id=H5Tget_size(atype); 
     1529          if (size_id==4) 
     1530          { 
     1531              memtype_id = H5T_NATIVE_FLOAT;  
     1532          } else if (size_id==8) { 
     1533              memtype_id = H5T_NATIVE_DOUBLE; 
     1534          } 
    14671535      }            
    14681536      if (memtype_id == -1) 
    14691537      { 
    1470          NXIReportError (NXpData, "ERROR: h5MemType: invalid type"); 
     1538          NXIReportError (NXpData, "ERROR: h5MemType: invalid type"); 
    14711539      } 
    14721540      return memtype_id; 
    1473 } 
     1541  } 
    14741542  /*-------------------------------------------------------------------------*/ 
    14751543 
     
    14791547    hid_t grp, attr1,type,atype; 
    14801548    int iRet,iPtype, i; 
    1481     int idx,data_id,size_id, sign_id; 
     1549    int idx; 
     1550    H5T_class_t data_id; 
    14821551    char data[128]; 
    14831552    char ph_name[1024]; 
     
    16021671     pNexusFile5 pFile; 
    16031672     int iStart[H5S_MAX_RANK], status; 
    1604      hid_t data_id, memtype_id, size_id, sign_id;     
     1673     hid_t memtype_id;  
     1674     H5T_class_t data_id; 
    16051675     int dims;     
    16061676 
     
    16491719     int i, iRank, mType, iRet; 
    16501720     hsize_t myDim[H5S_MAX_RANK];  
    1651      hid_t data_id,size_id,sign_id; 
     1721     H5T_class_t data_id; 
    16521722 
    16531723     pFile = NXI5assert (fid); 
     
    16841754     hsize_t mySize[H5S_MAX_RANK]; 
    16851755     hsize_t mStart[H5S_MAX_RANK]; 
    1686      hid_t   memspace, iRet, data_id; 
    1687      hid_t   memtype_id, size_id, sign_id; 
     1756     hid_t   memspace, iRet; 
     1757     H5T_class_t data_id; 
     1758     hid_t   memtype_id; 
    16881759     char *tmp_data = NULL; 
    16891760     char *data1; 
     
    17401811        } 
    17411812       /* map datatypes of other plateforms */ 
    1742        if (data_id==H5T_STRING) 
     1813       if (data_id == H5T_STRING) 
    17431814       { 
    17441815         dims = H5Tget_size(pFile->iCurrentT); 
     
    17621833                     pFile->iCurrentS, H5P_DEFAULT,data); 
    17631834      }     
     1835      /* cleanup */ 
     1836      if (data_id == H5T_STRING) { /* we used H5Tcopy */ 
     1837         H5Tclose(memtype_id); 
     1838      } 
     1839      H5Sclose(memspace); 
    17641840 
    17651841      if (iRet < 0)  
     1842 
    17661843        { 
    17671844          NXIReportError (NXpData, "ERROR: Reading slab failed"); 
     
    17851862   { 
    17861863     pNexusFile5 pFile; 
    1787      hid_t attr_id,size_id,sign_id; 
     1864     hid_t attr_id; 
    17881865     hid_t iRet, atype, aspace; 
    17891866     int iPType,rank; 
     
    19252002     unsigned int idx; 
    19262003     int vid; 
    1927      herr_t iRet; 
    1928  
     2004     
    19292005     pFile = NXI5assert (fid); 
    19302006     idx=0; 
     
    19522028  { 
    19532029    pNexusFile5 pFile; 
    1954     int u, datalen, type = NX_CHAR; 
    1955     char group_name[64], class_name[64]; 
    1956     ErrFunc oldErr; 
     2030    int datalen, type = NX_CHAR; 
    19572031   
    19582032    pFile = NXI5assert (fileid); 
     
    19652039        the path to the current node 
    19662040      */ 
    1967       oldErr = NXMGetError(); 
    1968       NXMSetError(NXpData, ignoreError); 
     2041      NXMDisableErrorReporting(); 
    19692042      datalen = 1024; 
    19702043      memset(sRes->targetPath,0,datalen*sizeof(char)); 
     
    19722045        buildCurrentPath(pFile,sRes->targetPath,1024); 
    19732046      } 
    1974       NXMSetError(NXpData,oldErr); 
     2047      NXMEnableErrorReporting(); 
    19752048      sRes->linkType = 0; 
    19762049      return NX_OK; 
     
    20492122      fHandle->nxprintlink=NX5printlink; 
    20502123} 
     2124 
     2125#endif /* HDF5 */ 
  • tags/4.2.1/src/nexus_symbols.txt

    r1924 r1924  
    1313nxifputattr_ 
    1414nxifree_ 
     15nxifgetpath_ 
    1516nxigetattr_ 
    1617nxigetattrinfo_ 
     
    3435nxiopengrouppath_ 
    3536nxiopenpath_ 
     37nxigetpath_ 
    3638nxiopensourcegroup_ 
    3739nxiputattr_ 
     
    4547nxiisexternalgroup_ 
    4648NXMSetError 
     49NXMSetTError 
    4750NXIReportError 
    4851NXIprintlink 
  • tags/4.2.1/src/nxdataset.c

    r1924 r1924  
    179179double getNXDatasetValue(pNXDS dataset, int pos[]){ 
    180180  int address; 
    181   double value; 
    182  
     181  
    183182  if(dataset == NULL){ 
    184183    return 0; 
     
    230229char  *getNXDatasetText(pNXDS dataset){ 
    231230  char *resultBuffer = NULL; 
    232   int length, status = 1; 
     231  int status = 1; 
    233232 
    234233  if(dataset == NULL){ 
  • tags/4.2.1/src/nxio.c

    r1924 r1924  
    2424 *  For further information, see <http://www.neutron.anl.gov/NeXus/> 
    2525 */ 
    26 #include <mxml.h> 
     26 
     27#ifdef NXXML  
     28 
     29#include <mxml.h>  
    2730#include <assert.h> 
    2831#include "napi.h" 
     
    327330  const char *typeString; 
    328331  mxml_node_t* tnode; 
    329   mxml_type_t myType; 
    330   int i, nx_type = -1; 
     332  int nx_type = -1; 
    331333  int table_mode = 0; 
    332334 
     
    403405mxml_type_t nexusTypeCallback(mxml_node_t *parent){ 
    404406  const char *typeString; 
    405   mxml_node_t * tnode; 
    406407 
    407408  if(strstr(parent->value.element.name,"?xml") != NULL || 
     
    443444  long address, maxAddress; 
    444445  pNXDS dataset = NULL; 
    445   int i, table_mode; 
     446  int table_mode; 
    446447 
    447448  parent = node->parent; 
     
    479480static void stringIntoBuffer(char **buffer, char **bufPtr, int *bufSize,  
    480481                      char *string){ 
    481   int i; 
     482  size_t i; 
    482483 
    483484  for(i = 0; i < strlen(string); i++){ 
     
    737738} 
    738739#endif 
     740 
     741 
     742#endif /*NXXML*/  
  • tags/4.2.1/src/nxstack.c

    r1924 r1924  
    2020  
    2121  For further information, see <http://www.neutron.anl.gov/NeXus/> 
     22 
     23  Added code to support the path stack for NXgetpath,  
     24        Mark Koennecke, October 2009 
    2225*/ 
    2326#include <stdlib.h> 
     
    4043  int fileStackPointer; 
    4144  fileStackEntry fileStack[MAXEXTERNALDEPTH]; 
     45  int pathPointer; 
     46  char pathStack[NXMAXSTACK][NX_MAXNAMELEN]; 
    4247}fileStack; 
    4348/*---------------------------------------------------------------------*/ 
     
    5156  memset(pNew,0,sizeof(fileStack)); 
    5257  pNew->fileStackPointer = -1; 
     58  pNew->pathPointer = -1; 
    5359  return pNew; 
    5460} 
     
    5864    free(self); 
    5965  } 
     66} 
     67/*---------------------------------------------------------------------*/ 
     68int getFileStackSize(){ 
     69  return sizeof(fileStack); 
    6070} 
    6171/*----------------------------------------------------------------------*/ 
     
    99109  return self->fileStackPointer; 
    100110} 
     111/*----------------------------------------------------------------------*/ 
     112void pushPath(pFileStack self, const char *name){ 
     113  self->pathPointer++; 
     114  strncpy(self->pathStack[self->pathPointer],name,NX_MAXNAMELEN-1); 
     115} 
     116/*-----------------------------------------------------------------------*/ 
     117void popPath(pFileStack self){ 
     118  self->pathPointer--; 
     119  if(self->pathPointer < -1){ 
     120    self->pathPointer = -1; 
     121  } 
     122} 
     123/*-----------------------------------------------------------------------*/ 
     124int buildPath(pFileStack self, char *path, int pathlen){ 
     125  int i, totalPathLength; 
     126  char *totalPath; 
     127 
     128  for(i = 0, totalPathLength = 5; i <= self->pathPointer; i++){ 
     129    totalPathLength += strlen(self->pathStack[i]) + 1; 
     130  } 
     131  totalPath = malloc(totalPathLength*sizeof(char)); 
     132  if(totalPath == NULL){ 
     133    return 0; 
     134  } 
     135  memset(totalPath,0,totalPathLength*sizeof(char)); 
     136  for(i = 0; i <= self->pathPointer; i++){ 
     137    strcat(totalPath,"/"); 
     138    strcat(totalPath,self->pathStack[i]); 
     139  } 
     140   
     141  strncpy(path,totalPath,pathlen-1); 
     142  free(totalPath); 
     143  return 1; 
     144} 
  • tags/4.2.1/src/nxstack.h

    r1924 r1924  
    2020  
    2121  For further information, see <http://www.neutron.anl.gov/NeXus/> 
     22 
     23  Added functions to deal with the path stack for NXgetpath 
     24  Mark Koennecke, October 2009 
     25 
    2226*/ 
    2327#ifndef NEXUSFILESTACK 
     
    2933pFileStack makeFileStack(); 
    3034void killFileStack(pFileStack self); 
     35int getFileStackSize(); 
    3136 
    3237void pushFileStack(pFileStack self, pNexusFunction pDriv, char *filename); 
     
    4045int fileStackDepth(pFileStack self); 
    4146 
     47void pushPath(pFileStack self, const char *name); 
     48void popPath(pFileStack self); 
     49int buildPath(pFileStack self, char *path, int pathlen); 
     50 
    4251#endif 
    4352 
  • tags/4.2.1/src/nxxml.c

    r1924 r1924  
    2121 *  For further information, see <http://www.nexusformat.org> 
    2222 */ 
     23 
     24 
     25#ifdef NXXML  
     26 
    2327#include <stdio.h> 
    2428#include <napi.h> 
     
    7175#define XMLSTACK_OPTION_TABLE           0x1 /**< indicates table option in xmlStack */ 
    7276 
    73 /** 
    74  * Freddie Akeroyd 14/7/2008 
    75  * Add NeXus schema support - this uses BASE.xsd as the initial file 
    76  */ 
    77 #define NEXUS_SCHEMA_VERSION    "3.0"   /**< version of NeXus definition schema */ 
    78 #define NEXUS_SCHEMA_NAMESPACE  "http://definition.nexusformat.org/schema/" NEXUS_SCHEMA_VERSION        /**< XML schema namespace specified by xmlns */ 
    79 #define NEXUS_SCHEMA_FILE       NEXUS_SCHEMA_NAMESPACE "/BASE.xsd" /**< location of default schema file for namespace */ 
    8077 
    8178/*---------------------------------------------------------------------*/ 
     
    184181    mxmlElementSetAttr(current,"xmlns:xsi","http://www.w3.org/2001/XMLSchema-instance"); 
    185182    mxmlElementSetAttr(current,"xsi:schemaLocation", 
    186         NEXUS_SCHEMA_NAMESPACE " " NEXUS_SCHEMA_FILE); 
     183        NEXUS_SCHEMA_NAMESPACE " " NEXUS_SCHEMA_URL); 
    187184    time_buffer = NXIformatNeXusTime(); 
    188185    if(time_buffer != NULL){ 
     
    349346  pXMLNexus xmlHandle = NULL; 
    350347  mxml_node_t *newGroup = NULL; 
    351   char error[1024]; 
    352348 
    353349  xmlHandle = (pXMLNexus)fid; 
     
    395391 
    396392  getNumberText(datatype,typestring,130); 
    397   if(rank > 1 || dimensions[0] > 1) { 
     393  if(rank > 1 || datatype == NX_CHAR || dimensions[0] > 1) { 
    398394    strcat(typestring,"["); 
    399395    snprintf(pNumber,19,"%d",dimensions[0]); 
     
    727723  const char* name; 
    728724  pNXDS dataset; 
    729   int i, offset, length, type, rank, dim[NX_MAXRANK]; 
     725  int i, offset, length; 
    730726  char *pPtr = NULL; 
    731727  xmlHandle = (pXMLNexus)fid; 
     
    826822  const char* name; 
    827823  pNXDS dataset; 
    828   int i, offset, length, type, rank, dim[NX_MAXRANK]; 
     824  int i, offset, length; 
    829825  xmlHandle = (pXMLNexus)fid; 
    830826  assert(xmlHandle); 
     
    13001296  char error[1024]; 
    13011297  const char *attData = NULL; 
    1302   int iValue, nx_type; 
    1303   float fValue; 
     1298  int nx_type; 
    13041299 
    13051300  xmlHandle = (pXMLNexus)fid; 
     
    16711666  pXMLNexus xmlHandle = NULL; 
    16721667  mxml_node_t *current = NULL; 
    1673   int stackPtr, currentAtt, skip; 
     1668  int stackPtr, skip; 
    16741669 
    16751670  xmlHandle = (pXMLNexus)fid; 
     
    17471742  mxml_node_t *current = NULL; 
    17481743  char *pathString = NULL, *result = NULL; 
    1749   int count; 
    17501744 
    17511745  path = (mxml_node_t **)malloc(NXMAXSTACK*sizeof(mxml_node_t *)); 
    17521746  if(path == NULL){ 
    1753     NXIReportError(NXpData,"ERROR: out of memory follwoing link path"); 
     1747    NXIReportError(NXpData,"ERROR: out of memory following link path"); 
    17541748    return NULL; 
    17551749  } 
     
    19051899/*--------------------------------------------------------------------*/ 
    19061900int  NXXcompress(NXhandle fid, int comp){ 
    1907   NXIReportError(NXpData,"NXcompress is deprecated, IGNORED"); 
     1901  /* that will throw an exception in the Java API, errors have to be fatal */ 
     1902  /* NXIReportError(NXpData,"NXcompress is deprecated, IGNORED"); */ 
    19081903  return NX_OK; 
    19091904} 
     
    19421937} 
    19431938 
     1939 
     1940 
     1941#endif /*NXXML*/ 
  • tags/4.2.1/test

  • tags/4.2.1/test/atlocal.in

    r1924 r1924  
    2929export HAVE_XML 
    3030# 
    31 if test ! -z "@F77@"; then 
     31if test "@WITH_F77@" = "yes"; then 
    3232    HAVE_F77=run_test 
    3333else 
     
    3636export HAVE_F77 
    3737# 
    38 if test ! -z "@FC@"; then 
     38if test "@WITH_F90@" = "yes"; then 
    3939    HAVE_F90=run_test 
    4040else 
  • tags/4.2.1/test/leak_test2.cxx

    r1924 r1924  
    11#include <sstream> 
    22#include <cstdlib> 
     3#include <cstdio> 
    34#include <napi.h> 
    45#include <unistd.h> 
  • tags/4.2.1/test/napi_test.c

    r1924 r1924  
    6666  int64_t grossezahl[4]; 
    6767  const char* ch_test_data = "NeXus ><}&{'\\&\" Data"; 
     68  char path[512]; 
    6869 
    6970  grossezahl[0] = 12; 
     
    244245  NXgetattrinfo(fileid,&i); 
    245246  printf("Number of group attributes: %d\n", i); 
     247  if(NXgetpath(fileid,path,512) != NX_OK)return 1; 
     248  printf("NXentry path %s\n", path); 
    246249  do {  
    247250     attr_status = NXgetnextattr (fileid, name, NXdims, &NXtype); 
     
    270273        if (entry_status == NX_OK) { 
    271274           if (NXopendata (fileid, name) != NX_OK) return 1; 
    272               if (NXgetinfo (fileid, &NXrank, NXdims, &NXtype) != NX_OK) return 1; 
     275            if(NXgetpath(fileid,path,512) != NX_OK)return 1; 
     276            printf("Data path %s\n", path); 
     277            if (NXgetinfo (fileid, &NXrank, NXdims, &NXtype) != NX_OK) return 1; 
    273278                 printf ("   %s(%d)", name, NXtype); 
    274279              if (NXmalloc ((void **) &data_buffer, NXrank, NXdims, NXtype) != NX_OK) return 1; 
     
    365370  if (NXopengroup (fileid, "link", "NXentry") != NX_OK) return 1; 
    366371    if (NXopengroup (fileid, "sample", "NXsample") != NX_OK) return 1; 
     372    if(NXgetpath(fileid,path,512) != NX_OK)return 1; 
     373    printf("Group path %s\n", path); 
    367374      if (NXgetgroupID (fileid, &blink) != NX_OK) return 1; 
    368375        if (NXsameID(fileid, &glink, &blink) != NX_OK) 
  • tags/4.2.1/test/napi_test_cpp.cxx

    r1924 r1924  
    44#include <cstring> 
    55#include <cstdlib> 
     6#include <cstdio> 
    67#include <vector> 
    78#include "napiconfig.h" 
     
    274275        cout << toString(result); 
    275276      } 
     277      cout <<  endl; 
     278      cout << "   Path = " << file.getPath() << endl; 
     279      file.closeData(); 
    276280    } 
    277281    else { 
    278       cout << ":" << it->second; 
    279     } 
    280     cout <<  endl; 
     282      cout << ":" << it->second << endl; 
     283    } 
    281284  } 
    282285  file.closeGroup(); 
  • tags/4.2.1/test/napif4_test.f

    r1924 r1924  
    2727      INCLUDE 'napif.inc' 
    2828      INTEGER NXRANK, NXDIMS(NX_MAXRANK), NXTYPE, NXLEN 
    29       INTEGER ENTRY_STATUS, ATTR_STATUS 
     29      INTEGER ENTRY_STATUS, ATTR_STATUS, STAT 
    3030      INTEGER*4 I, J 
    3131      REAL*4 R 
     
    4141      CHARACTER*128 CHAR_BUFFER 
    4242      INTEGER*1 CHAR_BUFFER_B(128) 
    43       CHARACTER*64 GROUP_NAME, CLASS_NAME 
     43      CHARACTER*64 GROUP_NAME, CLASS_NAME, PATH 
    4444      INTEGER FILEID(NXHANDLESIZE) 
    4545      INTEGER GLINK(NXLINKSIZE), DLINK(NXLINKSIZE), BLINK(NXLINKSIZE) 
     
    141141                     IF (NXPUTSLAB(FILEID, U_BUFFER(I), SLAB_START,  
    142142     +                 SLAB_SIZE) .NE. NX_OK) STOP 
     143                     STAT = NXCLOSEDATA(FILEID) 
    143144                     IF (NXFLUSH(FILEID) .NE. NX_OK) STOP 
    144145               END DO 
     
    196197      ELSE IF (ENTRY_STATUS .EQ. NX_OK) THEN 
    197198         IF (NXOPENDATA(FILEID,NAME) .NE. NX_OK) STOP 
     199         IF(NXGETPATH(FILEID,PATH) .NE. NX_OK) STOP 
     200         WRITE(*,FMT='(1X,A,A)') 'Path = ', PATH(1:LEN_TRIM(PATH)) 
    198201         IF (NXGETINFO(FILEID,NXRANK,NXDIMS,NXTYPE) .NE. NX_OK) STOP 
    199202         WRITE(*,FMT='(4X,A,I2,A)') NAME(1:LEN_TRIM(NAME))//'(',  
  • tags/4.2.1/test/napif5_test.f

    r1924 r1924  
    2727      INCLUDE 'napif.inc' 
    2828      INTEGER NXRANK, NXDIMS(NX_MAXRANK), NXTYPE, NXLEN 
    29       INTEGER ENTRY_STATUS, ATTR_STATUS 
     29      INTEGER ENTRY_STATUS, ATTR_STATUS, STAT 
    3030      INTEGER*4 I, J 
    3131      REAL*4 R 
     
    4242      INTEGER*1 CHAR_BUFFER_B(128) 
    4343      CHARACTER*64 GROUP_NAME, CLASS_NAME 
     44      CHARACTER*70 PATH 
    4445      INTEGER FILEID(NXHANDLESIZE) 
    4546      INTEGER GLINK(NXLINKSIZE), DLINK(NXLINKSIZE), BLINK(NXLINKSIZE) 
     
    141142                     IF (NXPUTSLAB(FILEID, U_BUFFER(I), SLAB_START,  
    142143     +                 SLAB_SIZE) .NE. NX_OK) STOP 
     144                     STAT = NXCLOSEDATA(FILEID) 
    143145                     IF (NXFLUSH(FILEID) .NE. NX_OK) STOP 
    144146               END DO 
     
    196198      ELSE IF (ENTRY_STATUS .EQ. NX_OK) THEN 
    197199         IF (NXOPENDATA(FILEID,NAME) .NE. NX_OK) STOP 
     200         IF(NXGETPATH(FILEID,PATH) .NE. NX_OK) STOP 
     201         WRITE(*,FMT='(1X,A,A)') 'Path = ', PATH(1:LEN_TRIM(PATH)) 
    198202         IF (NXGETINFO(FILEID,NXRANK,NXDIMS,NXTYPE) .NE. NX_OK) STOP 
    199203         WRITE(*,FMT='(4X,A,I2,A)') NAME(1:LEN_TRIM(NAME))//'(',  
  • tags/4.2.1/test/napif_test.f

    r1924 r1924  
    4242      INTEGER*1 CHAR_BUFFER_B(128) 
    4343      CHARACTER*64 GROUP_NAME, CLASS_NAME 
     44      CHARACTER*70 PATH 
    4445      INTEGER FILEID(NXHANDLESIZE) 
    4546      INTEGER GLINK(NXLINKSIZE), DLINK(NXLINKSIZE), BLINK(NXLINKSIZE) 
     
    196197      ELSE IF (ENTRY_STATUS .EQ. NX_OK) THEN 
    197198         IF (NXOPENDATA(FILEID,NAME) .NE. NX_OK) STOP 
     199         IF (NXGETPATH(FILEID,PATH) .NE. NX_OK)STOP 
     200         WRITE(*,FMT='(1X,A,A)') 'Path = ', PATH(1:LEN_TRIM(PATH)) 
    198201         IF (NXGETINFO(FILEID,NXRANK,NXDIMS,NXTYPE) .NE. NX_OK) STOP 
    199202         WRITE(*,FMT='(4X,A,I2,A)') NAME(1:LEN_TRIM(NAME))//'(',  
  • tags/4.2.1/test/testsuite.at

    r1924 r1924  
    3131[[NXinquirefile found: NXtest.hdf 
    3232Number of global attributes: 4 
    33    NeXus_version = 4.2.0 
     33   NeXus_version = 4.2.1 
    3434   file_name = NXtest.hdf 
    3535Number of group attributes: 2 
     36NXentry path /entry 
    3637   hugo = namenlos 
    3738   cucumber = passion 
    3839Group: entry(NXentry) contains 9 items 
     40Data path /entry/ch_data 
    3941   ch_data(4) = NeXus ><}&{'\&" Data 
     42Data path /entry/c1_data 
    4043   c1_data(4) = abcdefghijklmnopqrst 
     44Data path /entry/i1_data 
    4145   i1_data(20) =  1 2 3 4 
     46Data path /entry/i2_data 
    4247   i2_data(22) =  1000 2000 3000 4000 
     48Data path /entry/i4_data 
    4349   i4_data(24) =  1000000 2000000 3000000 4000000 
     50Data path /entry/r4_data 
    4451   r4_data(5) 
    4552       1.000000 2.000000 3.000000 4.000000 
     
    4855       13.000000 14.000000 15.000000 16.000000 
    4956       17.000000 18.000000 19.000000 20.000000 
     57Data path /entry/r8_data 
    5058   r8_data(6) 
    5159       1.000000 2.000000 3.000000 4.000000 
     
    6169   Subgroup: data(NXdata) 
    6270   Subgroup: sample(NXsample) 
     71Group path /link/sample 
    6372Link check OK 
    6473NXopenpath checks OK 
     
    7786[[NXinquirefile found: NXtest.h5 
    7887Number of global attributes: 4 
    79    NeXus_version = 4.2.0 
     88   NeXus_version = 4.2.1 
    8089   file_name = NXtest.h5 
    8190Number of group attributes: 2 
     91NXentry path /entry 
    8292   hugo = namenlos 
    8393   cucumber = passion 
    8494Group: entry(NXentry) contains 10 items 
     95Data path /entry/c1_data 
    8596   c1_data(4) = abcdefghijklmnopqrst 
     97Data path /entry/ch_data 
    8698   ch_data(4) = NeXus ><}&{'\&" Data 
    8799   Subgroup: data(NXdata) 
     100Data path /entry/grosse_zahl 
    88101   grosse_zahl(26) =  12 555555555555 23 777777777777 
     102Data path /entry/i1_data 
    89103   i1_data(20) =  1 2 3 4 
     104Data path /entry/i2_data 
    90105   i2_data(22) =  1000 2000 3000 4000 
     106Data path /entry/i4_data 
    91107   i4_data(24) =  1000000 2000000 3000000 4000000 
     108Data path /entry/r4_data 
    92109   r4_data(5) 
    93110       1.000000 2.000000 3.000000 4.000000 
     
    96113       13.000000 14.000000 15.000000 16.000000 
    97114       17.000000 18.000000 19.000000 20.000000 
     115Data path /entry/r8_data 
    98116   r8_data(6) 
    99117       1.000000 2.000000 3.000000 4.000000 
     
    108126         target : /entry/r8_data 
    109127   Subgroup: sample(NXsample) 
     128Group path /link/sample 
    110129Link check OK 
    111130NXopenpath checks OK 
     
    124143[[NXinquirefile found: NXtest.hdf 
    125144Number of global attributes: 4 
    126    NeXus_version = 4.2.0 
     145   NeXus_version = 4.2.1 
    127146   file_name = NXtest.hdf 
    128147Number of group attributes: 2 
     148NXentry path /entry 
    129149   hugo = namenlos 
    130150   cucumber = passion 
    131151Group: entry(NXentry) contains 9 items 
     152Data path /entry/ch_data 
    132153   ch_data(4) = NeXus ><}&{'\&" Data 
     154Data path /entry/c1_data 
    133155   c1_data(4) = abcdefghijklmnopqrst 
     156Data path /entry/i1_data 
    134157   i1_data(20) =  1 2 3 4 
     158Data path /entry/i2_data 
    135159   i2_data(22) =  1000 2000 3000 4000 
     160Data path /entry/i4_data 
    136161   i4_data(24) =  1000000 2000000 3000000 4000000 
     162Data path /entry/r4_data 
    137163   r4_data(5) 
    138164       1.000000 2.000000 3.000000 4.000000 
     
    141167       13.000000 14.000000 15.000000 16.000000 
    142168       17.000000 18.000000 19.000000 20.000000 
     169Data path /entry/r8_data 
    143170   r8_data(6) 
    144171       1.000000 2.000000 3.000000 4.000000 
     
    154181   Subgroup: data(NXdata) 
    155182   Subgroup: sample(NXsample) 
     183Group path /link/sample 
    156184Link check OK 
    157185NXopenpath checks OK 
     
    170198[[NXinquirefile found: NXtest.h5 
    171199Number of global attributes: 4 
    172    NeXus_version = 4.2.0 
     200   NeXus_version = 4.2.1 
    173201   file_name = NXtest.h5 
    174202Number of group attributes: 2 
     203NXentry path /entry 
    175204   hugo = namenlos 
    176205   cucumber = passion 
    177206Group: entry(NXentry) contains 10 items 
     207Data path /entry/c1_data 
    178208   c1_data(4) = abcdefghijklmnopqrst 
     209Data path /entry/ch_data 
    179210   ch_data(4) = NeXus ><}&{'\&" Data 
    180211   Subgroup: data(NXdata) 
     212Data path /entry/grosse_zahl 
    181213   grosse_zahl(26) =  12 555555555555 23 777777777777 
     214Data path /entry/i1_data 
    182215   i1_data(20) =  1 2 3 4 
     216Data path /entry/i2_data 
    183217   i2_data(22) =  1000 2000 3000 4000 
     218Data path /entry/i4_data 
    184219   i4_data(24) =  1000000 2000000 3000000 4000000 
     220Data path /entry/r4_data 
    185221   r4_data(5) 
    186222       1.000000 2.000000 3.000000 4.000000 
     
    189225       13.000000 14.000000 15.000000 16.000000 
    190226       17.000000 18.000000 19.000000 20.000000 
     227Data path /entry/r8_data 
    191228   r8_data(6) 
    192229       1.000000 2.000000 3.000000 4.000000 
     
    201238         target : /entry/r8_data 
    202239   Subgroup: sample(NXsample) 
     240Group path /link/sample 
    203241Link check OK 
    204242NXopenpath checks OK 
     
    217255[[NXinquirefile found: NXtest.xml 
    218256Number of global attributes: 7 
    219    NeXus_version = 4.2.0 
     257   NeXus_version = 4.2.1 
    220258   file_name = NXtest.xml 
    221    xmlns = http://definition.nexusformat.org/schema/3.0 
     259   xmlns = http://definition.nexusformat.org/schema/3.1 
    222260   xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance 
    223    xsi:schemaLocation = http://definition.nexusformat.org/schema/3.0 http://definition.nexusformat.org/schema/3.0/BASE.xsd 
     261   xsi:schemaLocation = http://definition.nexusformat.org/schema/3.1 http://definition.nexusformat.org/schema/3.1/BASE.xsd 
    224262Number of group attributes: 2 
     263NXentry path /entry 
    225264   hugo = namenlos 
    226265   cucumber = passion 
    227266Group: entry(NXentry) contains 10 items 
     267Data path /entry/ch_data 
    228268   ch_data(4) = NeXus ><}&{'\&" Data 
     269Data path /entry/c1_data 
    229270   c1_data(4) = abcdefghijklmnopqrst 
     271Data path /entry/i1_data 
    230272   i1_data(20) =  1 2 3 4 
     273Data path /entry/i2_data 
    231274   i2_data(22) =  1000 2000 3000 4000 
     275Data path /entry/i4_data 
    232276   i4_data(24) =  1000000 2000000 3000000 4000000 
     277Data path /entry/r4_data 
    233278   r4_data(5) 
    234279       1.000000 2.000000 3.000000 4.000000 
     
    237282       13.000000 14.000000 15.000000 16.000000 
    238283       17.000000 18.000000 19.000000 20.000000 
     284Data path /entry/r8_data 
    239285   r8_data(6) 
    240286       1.000000 2.000000 3.000000 4.000000 
     
    248294         r4_attribute : 3.141593 
    249295         target : /entry/r8_data 
     296Data path /entry/grosse_zahl 
    250297   grosse_zahl(26) =  12 555555555555 23 777777777777 
    251298   Subgroup: data(NXdata) 
    252299   Subgroup: sample(NXsample) 
     300Group path /link/sample 
    253301Link check OK 
    254302NXopenpath checks OK 
     
    267315[[NXinquirefile found: NXtest.xml 
    268316Number of global attributes: 7 
    269    NeXus_version = 4.2.0 
     317   NeXus_version = 4.2.1 
    270318   file_name = NXtest.xml 
    271    xmlns = http://definition.nexusformat.org/schema/3.0 
     319   xmlns = http://definition.nexusformat.org/schema/3.1 
    272320   xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance 
    273    xsi:schemaLocation = http://definition.nexusformat.org/schema/3.0 http://definition.nexusformat.org/schema/3.0/BASE.xsd 
     321   xsi:schemaLocation = http://definition.nexusformat.org/schema/3.1 http://definition.nexusformat.org/schema/3.1/BASE.xsd 
    274322Number of group attributes: 2 
     323NXentry path /entry 
    275324   hugo = namenlos 
    276325   cucumber = passion 
    277326Group: entry(NXentry) contains 10 items 
     327Data path /entry/ch_data 
    278328   ch_data(4) = NeXus ><}&{'\&" Data 
     329Data path /entry/c1_data 
    279330   c1_data(4) = abcdefghijklmnopqrst 
     331Data path /entry/i1_data 
    280332   i1_data(20) =  1 2 3 4 
     333Data path /entry/i2_data 
    281334   i2_data(22) =  1000 2000 3000 4000 
     335Data path /entry/i4_data 
    282336   i4_data(24) =  1000000 2000000 3000000 4000000 
     337Data path /entry/r4_data 
    283338   r4_data(5) 
    284339       1.000000 2.000000 3.000000 4.000000 
     
    287342       13.000000 14.000000 15.000000 16.000000 
    288343       17.000000 18.000000 19.000000 20.000000 
     344Data path /entry/r8_data 
    289345   r8_data(6) 
    290346       1.000000 2.000000 3.000000 4.000000 
     
    298354         r4_attribute : 3.141593 
    299355         target : /entry/r8_data 
     356Data path /entry/grosse_zahl 
    300357   grosse_zahl(26) =  12 555555555555 23 777777777777 
    301358   Subgroup: data(NXdata) 
    302359   Subgroup: sample(NXsample) 
     360Group path /link/sample 
    303361Link check OK 
    304362NXopenpath checks OK 
     
    317375[[NXinquirefile found: NXtest-table.xml 
    318376Number of global attributes: 7 
    319    NeXus_version = 4.2.0 
     377   NeXus_version = 4.2.1 
    320378   file_name = NXtest-table.xml 
    321    xmlns = http://definition.nexusformat.org/schema/3.0 
     379   xmlns = http://definition.nexusformat.org/schema/3.1 
    322380   xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance 
    323    xsi:schemaLocation = http://definition.nexusformat.org/schema/3.0 http://definition.nexusformat.org/schema/3.0/BASE.xsd 
     381   xsi:schemaLocation = http://definition.nexusformat.org/schema/3.1 http://definition.nexusformat.org/schema/3.1/BASE.xsd 
    324382Number of group attributes: 2 
     383NXentry path /entry 
    325384   hugo = namenlos 
    326385   cucumber = passion 
    327386Group: entry(NXentry) contains 10 items 
     387Data path /entry/ch_data 
    328388   ch_data(4) = NeXus ><}&{'\&" Data 
     389Data path /entry/c1_data 
    329390   c1_data(4) = abcdefghijklmnopqrst 
     391Data path /entry/i1_data 
    330392   i1_data(20) =  1 2 3 4 
     393Data path /entry/i2_data 
    331394   i2_data(22) =  1000 2000 3000 4000 
     395Data path /entry/i4_data 
    332396   i4_data(24) =  1000000 2000000 3000000 4000000 
     397Data path /entry/grosse_zahl 
    333398   grosse_zahl(26) =  12 555555555555 23 777777777777 
     399Data path /entry/r4_data 
    334400   r4_data(5) 
    335401       1.000000 2.000000 3.000000 4.000000 
     
    338404       13.000000 14.000000 15.000000 16.000000 
    339405       17.000000 18.000000 19.000000 20.000000 
     406Data path /entry/r8_data 
    340407   r8_data(6) 
    341408       1.000000 2.000000 3.000000 4.000000 
     
    351418   Subgroup: data(NXdata) 
    352419   Subgroup: sample(NXsample) 
     420Group path /link/sample 
    353421Link check OK 
    354422NXopenpath checks OK 
     
    368436AT_CHECK([ $HAVE_F77 && $HAVE_HDF4 && $SETUP_TEST && napif_test-hdf4 | sed -e 's/\r$//' ], [],  
    369437[[ Number of global attributes:  4 
    370     NeXus_version = 4.2.0 
     438    NeXus_version = 4.2.1 
    371439    file_name = NXtest.nxs 
    372440 Group: entry(NXentry) contains  8 items 
     441 Path = /entry/ch_data 
    373442    ch_data( 4) 
    374443    Values : NeXus data 
     444 Path = /entry/i1_data 
    375445    i1_data(20) 
    376446    Values :   1  2  3  4 
     447 Path = /entry/i2_data 
    377448    i2_data(22) 
    378449    Values :   1000  2000  3000  4000 
     450 Path = /entry/i4_data 
    379451    i4_data(24) 
    380452    Values :      1000000     2000000     3000000     4000000 
     453 Path = /entry/r4_data 
    381454    r4_data( 5) 
    382455    Values :    1.00   2.00   3.00   4.00 
     
    385458           :   13.00  14.00  15.00  16.00 
    386459           :   17.00  18.00  19.00  20.00 
     460 Path = /entry/r8_data 
    387461    r8_data( 6) 
    388462    Values :    1.00   2.00   3.00   4.00 
     
    404478AT_CHECK([ $HAVE_F77 && $HAVE_HDF5 && $SETUP_TEST && napif_test-hdf5 | sed -e 's/\r$//' ], [],  
    405479[[ Number of global attributes:  4 
    406     NeXus_version = 4.2.0 
     480    NeXus_version = 4.2.1 
    407481    file_name = NXtest.nxs 
    408482 Group: entry(NXentry) contains  8 items 
     483 Path = /entry/ch_data 
    409484    ch_data( 4) 
    410485    Values : NeXus data 
    411486    Subgroup: data(NXdata) 
     487 Path = /entry/i1_data 
    412488    i1_data(20) 
    413489    Values :   1  2  3  4 
     490 Path = /entry/i2_data 
    414491    i2_data(22) 
    415492    Values :   1000  2000  3000  4000 
     493 Path = /entry/i4_data 
    416494    i4_data(24) 
    417495    Values :      1000000     2000000     3000000     4000000 
     496 Path = /entry/r4_data 
    418497    r4_data( 5) 
    419498    Values :    1.00   2.00   3.00   4.00 
     
    422501           :   13.00  14.00  15.00  16.00 
    423502           :   17.00  18.00  19.00  20.00 
     503 Path = /entry/r8_data 
    424504    r8_data( 6) 
    425505    Values :    1.00   2.00   3.00   4.00 
     
    441521[[Writing character data 
    442522Number of global attributes:        4 
    443    NeXus_version = 4.2.0 
     523   NeXus_version = 4.2.1 
    444524   file_name = NXtest.nxs 
    445525Group: entry(NXentry) contains        8 items 
     
    479559[[NXinquirefile found: napi_test_cpp.hdf 
    480560Number of global attributes: 4 
    481    NeXus_version = 4.2.0 
     561   NeXus_version = 4.2.1 
    482562   file_name = napi_test_cpp.hdf 
    483563Number of group attributes: 2 
     
    486566Group contains 9 items 
    487567   c1_data[5,4] = 2d character array 
     568   Path = /entry/c1_data 
    488569   ch_data[10] = NeXus_data 
     570   Path = /entry/ch_data 
    489571   data:NXdata 
    490572   i1_data[4] = [,,,] 
     573   Path = /entry/i1_data 
    491574   i2_data[4] = [1000,2000,3000,4000] 
     575   Path = /entry/i2_data 
    492576   i4_data[4] = [1000000,2000000,3000000,4000000] 
     577   Path = /entry/i4_data 
    493578   r4_data[5,4] = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19] 
     579   Path = /entry/r4_data 
    494580   r8_data[5,4] = [20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39] 
     581   Path = /entry/r8_data 
    495582   sample:NXsample 
    496583Link check OK 
     
    508595[[NXinquirefile found: napi_test_cpp.h5 
    509596Number of global attributes: 4 
    510    NeXus_version = 4.2.0 
     597   NeXus_version = 4.2.1 
    511598   file_name = napi_test_cpp.h5 
    512599Number of group attributes: 2 
     
    515602Group contains 10 items 
    516603   c1_data[5,4] = 2d character array 
     604   Path = /entry/c1_data 
    517605   ch_data[10] = NeXus_data 
     606   Path = /entry/ch_data 
    518607   data:NXdata 
    519608   grosszahl[4] = [12,555555555555,23,777777777777] 
     609   Path = /entry/grosszahl 
    520610   i1_data[4] = [,,,] 
     611   Path = /entry/i1_data 
    521612   i2_data[4] = [1000,2000,3000,4000] 
     613   Path = /entry/i2_data 
    522614   i4_data[4] = [1000000,2000000,3000000,4000000] 
     615   Path = /entry/i4_data 
    523616   r4_data[5,4] = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19] 
     617   Path = /entry/r4_data 
    524618   r8_data[5,4] = [20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39] 
     619   Path = /entry/r8_data 
    525620   sample:NXsample 
    526621Link check OK 
     
    538633[[NXinquirefile found: napi_test_cpp.xml 
    539634Number of global attributes: 7 
    540    NeXus_version = 4.2.0 
     635   NeXus_version = 4.2.1 
    541636   file_name = napi_test_cpp.xml 
    542    xmlns = http://definition.nexusformat.org/schema/3.0 
     637   xmlns = http://definition.nexusformat.org/schema/3.1 
    543638   xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance 
    544    xsi:schemaLocation = http://definition.nexusformat.org/schema/3.0 http://definition.nexusformat.org/schema/3.0/BASE.xsd 
     639   xsi:schemaLocation = http://definition.nexusformat.org/schema/3.1 http://definition.nexusformat.org/schema/3.1/BASE.xsd 
    545640Number of group attributes: 2 
    546641   hugo = namenlos 
     
    548643Group contains 10 items 
    549644   c1_data[5,4] = 2d character array 
     645   Path = /entry/c1_data 
    550646   ch_data[10] = NeXus_data 
     647   Path = /entry/ch_data 
    551648   data:NXdata 
    552649   grosszahl[4] = [12,555555555555,23,777777777777] 
     650   Path = /entry/grosszahl 
    553651   i1_data[4] = [,,,] 
     652   Path = /entry/i1_data 
    554653   i2_data[4] = [1000,2000,3000,4000] 
     654   Path = /entry/i2_data 
    555655   i4_data[4] = [1000000,2000000,3000000,4000000] 
     656   Path = /entry/i4_data 
    556657   r4_data[5,4] = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19] 
     658   Path = /entry/r4_data 
    557659   r8_data[5,4] = [20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39] 
     660   Path = /entry/r8_data 
    558661   sample:NXsample 
    559662Link check OK 
     
    713816 
    714817attribute name: NeXus_version 
    715 attribute value: 4.2.0 
     818attribute value: 4.2.1 
    716819 
    717820NXgetnextattr status:        1 
     
    11301233 
    11311234attribute name: NeXus_version 
    1132 attribute value: 4.2.0 
     1235attribute value: 4.2.1 
    11331236 
    11341237NXgetnextattr status:        1 
     
    15471650 
    15481651attribute name: NeXus_version 
    1549 attribute value: 4.2.0 
     1652attribute value: 4.2.1 
    15501653 
    15511654NXgetnextattr status:        1 
     
    15621665 
    15631666attribute name: xmlns 
    1564 attribute value: http://definition.nexusformat.org/schema/3.0 
     1667attribute value: http://definition.nexusformat.org/schema/3.1 
    15651668 
    15661669NXgetnextattr status:        1 
     
    15721675 
    15731676attribute name: xsi:schemaLocation 
    1574 attribute value: http://definition.nexusformat.org/schema/3.0 http://definition.nexusformat.org/schema/3.0/BASE.xsd 
     1677attribute value: http://definition.nexusformat.org/schema/3.1 http://definition.nexusformat.org/schema/3.0/BASE.xsd 
    15751678 
    15761679NXgetnextattr status:        1 
     
    19252028AT_BANNER([[Testing NXbrowse Tool.]]) 
    19262029AT_SETUP([Checking HDF4 test file]) 
    1927 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/[ ]*$//' ],[],  
    1928 [[NXBrowse 4.2.0 Copyright (C) 2000 R. Osborn, M. Koennecke, P. Klosowski 
    1929     NeXus_version = 4.2.0 
     2030AT_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/[ ]*$//' ],[],  
     2031[[NXBrowse 4.2.1 Copyright (C) 2009 NeXus Data Format 
     2032    NeXus_version = 4.2.1 
    19302033    file_name = NXtest.hdf 
    19312034NX>   NX Group : entry (NXentry) 
     
    19372040AT_CLEANUP 
    19382041AT_SETUP([Checking HDF5 test file]) 
    1939 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/[ ]*$//' ],[],  
    1940 [[NXBrowse 4.2.0 Copyright (C) 2000 R. Osborn, M. Koennecke, P. Klosowski 
    1941     NeXus_version = 4.2.0 
     2042AT_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/[ ]*$//' ],[],  
     2043[[NXBrowse 4.2.1 Copyright (C) 2009 NeXus Data Format 
     2044    NeXus_version = 4.2.1 
    19422045    file_name = NXtest.h5 
    19432046NX>   NX Group : entry (NXentry) 
     
    19492052AT_CLEANUP 
    19502053AT_SETUP([Checking XML test file]) 
    1951 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/[ ]*$//' ],[],  
    1952 [[NXBrowse 4.2.0 Copyright (C) 2000 R. Osborn, M. Koennecke, P. Klosowski 
    1953     NeXus_version = 4.2.0 
     2054AT_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/[ ]*$//' ],[],  
     2055[[NXBrowse 4.2.1 Copyright (C) 2009 NeXus Data Format 
     2056    NeXus_version = 4.2.1 
    19542057    file_name = NXtest.xml 
    1955     xmlns = http://definition.nexusformat.org/schema/3.0 
     2058    xmlns = http://definition.nexusformat.org/schema/3.1 
    19562059    xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance 
    1957     xsi:schemaLocation = http://definition.nexusformat.org/schema/3.0 http://definition.nexusformat.org/schema/3.0/BASE.xsd 
     2060    xsi:schemaLocation = http://definition.nexusformat.org/schema/3.1 http://definition.nexusformat.org/schema/3.1/BASE.xsd 
    19582061NX>   NX Group : entry (NXentry) 
    19592062             entry attribute: hugo = namenlos 
     
    19832086]]) 
    19842087AT_CLEANUP 
    1985  
    1986  
    1987 AT_BANNER([[Testing validating files with the nxvalidate tool.]]) 
    1988 AT_SETUP([Checking HDF4 test file via web (wget)]) 
    1989 AT_CHECK([$HAVE_HDF4 && $HAVE_WGET && $SETUP_TEST && napi_test-hdf4 -q && nxvalidate -q -w NXtest.hdf | sed -e 's/\r$//' ],[],  
    1990 [[]]) 
    1991 AT_CLEANUP 
    1992 AT_SETUP([Checking HDF5 test file via web (wget)]) 
    1993 AT_CHECK([$HAVE_HDF4 && $HAVE_WGET && $SETUP_TEST && napi_test-hdf5 -q && nxvalidate -q -w NXtest.h5 | sed -e 's/\r$//' ],[],  
    1994 [[]]) 
    1995 AT_CLEANUP 
    1996 AT_SETUP([Checking XML test file via web (wget)]) 
    1997 AT_CHECK([$HAVE_HDF4 && $HAVE_WGET && $SETUP_TEST && napi_test-xml -q && nxvalidate -q -w NXtest.xml | sed -e 's/\r$//' ],[],  
    1998 [[]]) 
    1999 AT_CLEANUP 
Note: See TracChangeset for help on using the changeset viewer.