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.