source: trunk/bindings/idl/NeXusIDL-API.c @ 1822

Revision 1375, 76.9 KB checked in by Mark Koennecke, 3 years ago (diff)
  • Implemented NXgetpath for C, C++, Java, SWIG and F77, refs #199
  • Python still needs to be done but I think python has an own implementation.
  • I added to the test code: now as they are based on text comparison all of them fail :-(
Line 
1/*
2  NeXus - Neutron & X-ray Common Data Format
3 
4  IDL Application Program Interface Routines
5 
6  Copyright (C) 2007-* Jussi Kauppila, Mark Koennecke
7 
8  This library is free software; you can redistribute it and/or
9  modify it under the terms of the GNU Lesser General Public
10  License as published by the Free Software Foundation; either
11  version 2 of the License, or (at your option) any later version.
12 
13  This library is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  Lesser General Public License for more details.
17 
18  You should have received a copy of the GNU Lesser General Public
19  License along with this library; if not, write to the Free Software
20  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21 
22  For further information, see <http://www.nexusformat.org>
23*/
24#include <stdio.h>
25#include <stdlib.h>
26#include "idl_export.h"
27#include "../../include/napi.h"
28#include "handle.h"
29
30/* Windows path: */
31/* #include "C:\Program Files\NeXus Data Format\include\napi.h" */
32
33/* prototype for IDL_Load */
34int IDL_Load( void );
35
36/*
37 * Define message codes and their corresponding printf(3) format
38 * strings. Note that message codes start at zero and each one is
39 * one less that the previous one. Codes must be monotonic and
40 * contiguous.
41 */
42static IDL_MSG_DEF msg_arr[] =
43{
44#define M_TM_INPRO                       0
45  {  "M_TM_INPRO",   "%NThis is from a loadable module procedure." },
46#define M_TM_INFUN                       -1
47  {  "M_TM_INFUN",   "%NThis is from a loadable module function." },
48};
49
50/*
51 * The load function fills in this message block handle with the
52 * opaque handle to the message block used for this module. The other
53 * routines can then use it to throw errors from this block.
54 */
55static IDL_MSG_BLOCK msg_block;
56
57static char nexusError[1024];
58
59static void idlError(void *pData, char *message){
60        strncpy(nexusError,message,1023);
61}
62
63/* Implementation of the NeXus IDL API */
64
65/*======================================================================
66 * NxOpen
67 * status = NXopen (file_name, access_method, file_id)
68 *======================================================================*/
69static IDL_VPTR NXopen_this(int argc, IDL_VPTR *argv)
70{
71  IDL_VPTR result;
72  int status, iHandle;
73  NXaccess am;
74  char* accesstype;
75  char* path;
76  NXhandle hHandle;
77
78  /* if ENSURE fails it jumps a "long jump" back and complains but the
79     proper NX_ERROR status is not returned. Maybe write an own macro */
80  IDL_ENSURE_STRING(argv[0]);
81  IDL_ENSURE_STRING(argv[1]);
82
83  /* Convert argumets from IDL side to C-land */
84  path = IDL_VarGetString(argv[0]);
85  accesstype = IDL_VarGetString(argv[1]);
86
87  /* If number of arguments is not 3 return status NX_ERROR */
88  if (argc != 3) {
89        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Three arguments expected");
90        return IDL_GettmpInt(NX_ERROR);
91        }
92
93
94  /* If the accesstype isn't NXACC_CREATE5 NXACC_CREATE NXACC_READ,NXACC_RDWR return NX_ERROR */
95
96   if (strcmp(accesstype,"NXACC_CREATE5") == 0) {;
97       am = NXACC_CREATE5;
98    } else if (strcmp(accesstype,"NXACC_CREATE") == 0) {
99       am = NXACC_CREATE;
100    } else if (strcmp(accesstype,"NXACC_CREATE4") == 0) {
101       am = NXACC_CREATE4;
102    } else if (strcmp(accesstype,"NXACC_CREATEXML") == 0) {
103       am = NXACC_CREATEXML;
104    } else if (strcmp(accesstype,"NXACC_READ") == 0) {
105       am = NXACC_READ;
106    } else if (strcmp(accesstype,"NXACC_RDWR") == 0) {
107       am = NXACC_RDWR;
108    } else {
109       IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown Access Type");
110       return IDL_GettmpInt(NX_ERROR);
111    }
112
113  NXMSetError(NULL,idlError);
114  status = NXopen (path, am, &hHandle);
115  if(status == NX_ERROR){
116        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
117        return IDL_GettmpInt(NX_ERROR);
118  }
119
120  iHandle = HHMakeHandle(hHandle);
121    if(iHandle == -1) {
122        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Error creating the handle");
123                return IDL_GettmpInt(NX_ERROR);
124        }
125
126
127  result = IDL_GettmpInt(iHandle);
128
129  /* Output argument */
130  IDL_VarCopy(result, argv[2]);
131
132  return IDL_GettmpInt(status);
133}
134
135
136/*======================================================================
137 * Nxopenpath
138 * status = NXopenpath(file_id, path_string)
139 *======================================================================*/
140
141static IDL_VPTR NXopenpath_this(int argc, IDL_VPTR *argv)
142{
143  int fileid;
144  NXhandle hHandle;
145  int iHandle, status;
146  char* path;
147
148  if (argc != 2) {
149        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Two arguments expected");
150        return IDL_GettmpInt(NX_ERROR);
151        }
152
153  IDL_ENSURE_SCALAR(argv[0]);
154  IDL_ENSURE_STRING(argv[1]);
155
156  fileid = (int)IDL_LongScalar(argv[0]);
157  path = IDL_VarGetString(argv[1]);
158
159
160  if(HHCheckIfHandleExists(fileid) == -1) {
161        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
162        return IDL_GettmpInt(NX_ERROR);
163        }
164
165  hHandle = HHGetPointer(fileid);
166  NXMSetError(NULL,idlError);
167
168  status = NXopenpath (hHandle, path);
169  if(status == NX_ERROR){
170        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
171        return IDL_GettmpInt(NX_ERROR);
172  }
173
174
175  return IDL_GettmpInt(status);
176}
177
178
179/*======================================================================
180 * NXopengrouppath
181 * status = NXopengrouppath(file_id, path_string)
182 *======================================================================*/
183
184static IDL_VPTR NXopengrouppath_this(int argc, IDL_VPTR *argv)
185{
186  int fileid;
187  NXhandle hHandle;
188  int iHandle, status;
189  char* path;
190
191  if (argc != 2) {
192        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Two arguments expected");
193        return IDL_GettmpInt(NX_ERROR);
194        }
195
196  IDL_ENSURE_SCALAR(argv[0]);
197  IDL_ENSURE_STRING(argv[1]);
198
199  fileid = (int)IDL_LongScalar(argv[0]);
200  path = IDL_VarGetString(argv[1]);
201
202
203  if(HHCheckIfHandleExists(fileid) == -1) {
204        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
205        return IDL_GettmpInt(NX_ERROR);
206        }
207
208  hHandle = HHGetPointer(fileid);
209  NXMSetError(NULL,idlError);
210
211  status = NXopengrouppath (hHandle, path);
212  if(status == NX_ERROR){
213        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
214        return IDL_GettmpInt(NX_ERROR);
215  }
216
217
218  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);
254}
255
256/*======================================================================
257 * Nxclose
258 * status = NXclose (file_id)
259 *=======================================================================*/
260static IDL_VPTR  NXclose_this(int argc, IDL_VPTR *argv)
261{
262  int fileid;
263  NXhandle hHandle;
264  int iHandle, status;
265
266  /* If number of arguments is not 2 return 0 */
267  if (argc != 1) {
268        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "One argument expected");
269        return IDL_GettmpInt(NX_ERROR);
270        }
271
272  IDL_ENSURE_SCALAR(argv[0]);
273  /* Convert IDL variables from arguments to C-land */
274  fileid = (int) IDL_LongScalar(argv[0]);
275
276  if( HHCheckIfHandleExists(fileid) == -1) {
277        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
278        return IDL_GettmpInt(NX_ERROR);
279        }
280
281  hHandle = (int *)HHGetPointer(fileid);
282
283
284  NXMSetError(NULL,idlError);
285
286  status = NXclose (&hHandle);
287
288  if(status == NX_ERROR){
289        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
290        return IDL_GettmpInt(NX_ERROR);
291  }
292
293          HHRemoveHandle(fileid);
294
295  return IDL_GettmpInt(status);
296}
297
298/*======================================================================
299 * datatypecheck
300 *
301 *=======================================================================*/
302
303
304int datatypecheck(IDL_VPTR argv) {
305  int data_type;
306  char* datatype;
307
308  if(argv->type == IDL_TYP_STRING) {
309        IDL_ENSURE_STRING(argv);
310        datatype = IDL_VarGetString(argv);
311
312  if (strcmp(datatype,"NX_CHAR") == 0) {
313       data_type = NX_CHAR;
314    } else if (strcmp(datatype,"NX_INT8") == 0) {
315       data_type = NX_INT8;
316    } else if (strcmp(datatype,"NX_UINT8") == 0) {
317       data_type = NX_UINT8;
318    } else if (strcmp(datatype,"NX_INT16") == 0) {
319       data_type = NX_INT16;
320    } else if (strcmp(datatype,"NX_UINT16") == 0) {
321       data_type = NX_UINT16;
322    } else if (strcmp(datatype,"NX_INT32") == 0) {
323       data_type = NX_INT32;
324    } else if (strcmp(datatype,"NX_UINT32") == 0) {
325       data_type = NX_UINT32;
326    } else if (strcmp(datatype,"NX_FLOAT32") == 0) {
327       data_type = NX_FLOAT32;
328    } else if (strcmp(datatype,"NX_FLOAT64") == 0) {
329       data_type = NX_FLOAT64;
330    } else {
331                char statusBuffer[100];
332                sprintf(statusBuffer,"Unknown attribute datatype: %s", datatype );
333                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, statusBuffer);
334                return(-1);
335    }
336
337  }
338else {
339  IDL_ENSURE_SCALAR(argv);
340  data_type =  IDL_LongScalar(argv);
341  if(data_type == 4); else if (data_type == 5); else if (data_type == 6); else if
342     (data_type == 20); else if (data_type == 21); else if (data_type == 22); else if
343     (data_type == 23); else if (data_type == 24); else if (data_type == 25); else
344        {
345        char statusBuffer[100];
346        sprintf(statusBuffer,"Unknown attribute datatype: %i", data_type );
347        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, statusBuffer);
348        return(-1);
349        }
350  }
351
352 return(data_type);
353}
354
355
356/*======================================================================
357 * NXsetnumberformat
358 * status = NXsetnumberformat(file_id,data_type,format_string)
359 *=======================================================================*/
360
361static IDL_VPTR NXsetnumberformat_this(int argc, IDL_VPTR *argv)
362{
363  int fileid;
364  NXhandle hHandle;
365  int iHandle, status;
366  int data_type;
367  char* format_string;
368  char* datatype;
369
370  if (argc != 3) {
371        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Three arguments expected");
372        return IDL_GettmpInt(NX_ERROR);
373        }
374  IDL_ENSURE_SCALAR(argv[0]);
375
376  IDL_ENSURE_STRING(argv[2]);
377  format_string = IDL_VarGetString(argv[2]);
378
379
380  data_type = datatypecheck(argv[1]);
381  if(data_type == -1) return IDL_GettmpInt(NX_ERROR);
382
383/*if(argv[1]->type == IDL_TYP_STRING) {
384  IDL_ENSURE_STRING(argv[1]);
385  datatype = IDL_VarGetString(argv[1]);
386
387  if (strcmp(datatype,"NX_CHAR") == 0) {
388       data_type = NX_CHAR;
389    } else if (strcmp(datatype,"NX_INT8") == 0) {
390       data_type = NX_INT8;
391    } else if (strcmp(datatype,"NX_UINT8") == 0) {
392       data_type = NX_UINT8;
393    } else if (strcmp(datatype,"NX_INT16") == 0) {
394       data_type = NX_INT16;
395    } else if (strcmp(datatype,"NX_UINT16") == 0) {
396       data_type = NX_UINT16;
397    } else if (strcmp(datatype,"NX_INT32") == 0) {
398       data_type = NX_INT32;
399    } else if (strcmp(datatype,"NX_UINT32") == 0) {
400       data_type = NX_UINT32;
401    } else if (strcmp(datatype,"NX_FLOAT32") == 0) {
402       data_type = NX_FLOAT32;
403    } else if (strcmp(datatype,"NX_FLOAT64") == 0) {
404       data_type = NX_FLOAT64;
405    } else {
406                char statusBuffer[100];
407                sprintf(statusBuffer,"Unknown attribute datatype: %s", datatype );
408                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, statusBuffer);
409                return IDL_GettmpInt(NX_ERROR);
410    }
411
412  }
413else {
414  IDL_ENSURE_SCALAR(argv[1]);
415  data_type =  IDL_LongScalar(argv[1]);
416  if(data_type == 4); else if (data_type == 5); else if (data_type == 6); else if
417     (data_type == 20); else if (data_type == 21); else if (data_type == 22); else if
418     (data_type == 23); else if (data_type == 24); else if (data_type == 25); else
419        {
420        char statusBuffer[100];
421        sprintf(statusBuffer,"Unknown attribute datatype: %i", data_type );
422        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, statusBuffer);
423        return IDL_GettmpInt(NX_ERROR);
424        }
425  }*/
426
427  fileid = (int ) IDL_LongScalar(argv[0]);
428
429  if(HHCheckIfHandleExists(fileid) == -1) {
430        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
431        return IDL_GettmpInt(NX_ERROR);
432        }
433  hHandle = (int *)HHGetPointer(fileid);
434  NXMSetError(NULL,idlError);
435
436  status = NXsetnumberformat(hHandle, data_type,format_string);
437
438  if(status == NX_ERROR){
439        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
440        return IDL_GettmpInt(NX_ERROR);
441  }
442
443  return IDL_GettmpInt(status);
444}
445/*======================================================================
446 * NXmakegroup
447 * status = NXmakegroup (file_id, group_name, group_class)
448 *=======================================================================*/
449
450static IDL_VPTR NXmakegroup_this(int argc, IDL_VPTR *argv)
451{
452  int fileid;
453  NXhandle hHandle;
454  int iHandle, status;
455  char* group_name;
456  char* group_class;
457  if (argc != 3) {
458        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Three arguments expected");
459        return IDL_GettmpInt(NX_ERROR);
460        }
461
462  IDL_ENSURE_SCALAR(argv[0]);
463  IDL_ENSURE_STRING(argv[1]);
464  IDL_ENSURE_STRING(argv[2]);
465
466  fileid = (int)IDL_LongScalar(argv[0]);
467
468  group_name = IDL_VarGetString(argv[1]);
469  group_class = IDL_VarGetString(argv[2]);
470  if(HHCheckIfHandleExists(fileid) == -1) {
471        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
472        return IDL_GettmpInt(NX_ERROR);
473        }
474
475  hHandle = HHGetPointer(fileid);
476
477  NXMSetError(NULL,idlError);
478
479  status = NXmakegroup (hHandle, group_name, group_class);
480  if(status == NX_ERROR){
481        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
482        return IDL_GettmpInt(NX_ERROR);
483  }
484
485  return IDL_GettmpInt(status);
486}
487
488/*======================================================================
489 * Nxopengroup
490 * status = NXopengroup (file_id, group_name, group_class)
491 *=======================================================================*/
492
493static IDL_VPTR NXopengroup_this(int argc, IDL_VPTR *argv)
494{
495  int fileid;
496  NXhandle hHandle;
497  int iHandle, status;
498  char* group_name;
499  char* group_class;
500
501  if (argc != 3) {
502        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Three arguments expected");
503        return IDL_GettmpInt(NX_ERROR);
504        }
505
506  IDL_ENSURE_SCALAR(argv[0]);
507  IDL_ENSURE_STRING(argv[1]);
508  IDL_ENSURE_STRING(argv[2]);
509
510  fileid = (int)IDL_LongScalar(argv[0]);
511  group_name = IDL_VarGetString(argv[1]);
512  group_class = IDL_VarGetString(argv[2]);
513
514
515  if(HHCheckIfHandleExists(fileid) == -1) {
516        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
517        return IDL_GettmpInt(NX_ERROR);
518        }
519
520  hHandle = HHGetPointer(fileid);
521
522  NXMSetError(NULL,idlError);
523
524  status = NXopengroup (hHandle, group_name, group_class);
525  if(status == NX_ERROR){
526        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
527        return IDL_GettmpInt(NX_ERROR);
528  }
529
530
531  return IDL_GettmpInt(status);
532}
533
534/*======================================================================
535 * NXclosegroup
536 * status = NXclosegroup (file_id)
537 *=======================================================================*/
538
539static IDL_VPTR NXclosegroup_this(int argc, IDL_VPTR *argv)
540{
541
542  int fileid;
543  NXhandle hHandle;
544  int iHandle, status;
545
546  if (argc != 1) {
547        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "One argument expected");
548        return IDL_GettmpInt(NX_ERROR);
549        }
550
551  IDL_ENSURE_SCALAR(argv[0]);
552
553  fileid = (int )IDL_LongScalar(argv[0]);
554
555  if(HHCheckIfHandleExists(fileid) == -1) {
556        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
557        return IDL_GettmpInt(NX_ERROR);
558        }
559
560  hHandle = HHGetPointer(fileid);
561
562
563  NXMSetError(NULL,idlError);
564
565  status = NXclosegroup (hHandle);
566  if(status == NX_ERROR){
567        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
568        return IDL_GettmpInt(NX_ERROR);
569  }
570
571
572  return IDL_GettmpInt(status);
573}
574
575/*======================================================================
576 * NXopendata
577 * status = NXopendata (file_id, data_name)
578 *=======================================================================*/
579
580static IDL_VPTR NXopendata_this(int argc, IDL_VPTR *argv)
581{
582  int fileid;
583  NXhandle hHandle;
584  int iHandle, status;
585  char* data_name;
586
587  if (argc != 2) {
588        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Two arguments expected");
589        return IDL_GettmpInt(NX_ERROR);
590        }
591
592  IDL_ENSURE_SCALAR(argv[0]);
593  IDL_ENSURE_STRING(argv[1]);
594
595  fileid = (int )IDL_LongScalar(argv[0]);
596  data_name = IDL_VarGetString(argv[1]);
597
598  if(HHCheckIfHandleExists(fileid) == -1) {
599        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
600        return IDL_GettmpInt(NX_ERROR);
601        }
602
603  hHandle = HHGetPointer(fileid);
604
605  NXMSetError(NULL,idlError);
606
607  status = NXopendata (hHandle, data_name);
608  if(status == NX_ERROR){
609        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
610        return IDL_GettmpInt(NX_ERROR);
611  }
612
613
614  return IDL_GettmpInt(status);
615}
616
617
618/*======================================================================
619 * Nxclosedata
620 * status = NXclosedata (file_id)
621 *=======================================================================*/
622static IDL_VPTR  NXclosedata_this(int argc, IDL_VPTR *argv)
623{
624
625  int fileid;
626  NXhandle hHandle;
627  int iHandle, status;
628  NXlink data_id;
629
630  /* If number of arguments is not 2 return 0
631   Should be handled also with the calling conversion not shure if necessary..*/
632  if (argc != 1) {
633        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "One argument expected");
634        return IDL_GettmpInt(NX_ERROR);
635        }
636
637  IDL_ENSURE_SCALAR(argv[0]);
638
639  fileid = (int ) IDL_LongScalar(argv[0]);
640
641  if(HHCheckIfHandleExists(fileid) == -1) {
642        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
643        return IDL_GettmpInt(NX_ERROR);
644        }
645
646  hHandle = HHGetPointer(fileid);
647
648 /* status = NXgetdataID (hHandle, &data_id);
649  if(status == NX_ERROR) {
650                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Dataset must be opened before nxclosedata");
651                return IDL_GettmpInt(NX_ERROR);
652          }*/
653
654  NXMSetError(NULL,idlError);
655
656  status = NXclosedata (hHandle);
657  if(status == NX_ERROR){
658        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
659        return IDL_GettmpInt(NX_ERROR);
660  }
661
662
663  return IDL_GettmpInt(status);
664}
665
666/*======================================================================
667 * NXcompress
668 * statusstatus = NXcompress (file_id, compress_type)
669 *=======================================================================*/
670
671static IDL_VPTR NXcompress_this(int argc, IDL_VPTR *argv)
672{
673  int fileid;
674  NXhandle hHandle;
675  int iHandle, status;
676  int compresstype;
677  char* compress_type;
678  if (argc != 2) {
679        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Two arguments expected");
680        return IDL_GettmpInt(NX_ERROR);
681        }
682
683  IDL_ENSURE_SCALAR(argv[0]);
684  IDL_ENSURE_STRING(argv[1]);
685
686  fileid = (int )IDL_LongScalar(argv[0]);
687  compress_type = IDL_VarGetString(argv[1]);
688
689   if (strcmp(compress_type,"NX_COMP_LZW") == 0) {;
690       compresstype = NX_COMP_LZW;
691    } else if (strcmp(compress_type,"NX_COMP_HUF") == 0) {
692       compresstype = NX_COMP_HUF;
693    } else if (strcmp(compress_type,"NX_COMP_RLE") == 0) {
694       compresstype = NX_COMP_RLE;
695    } else {
696       IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown Compression Type");
697       return IDL_GettmpInt(NX_ERROR);
698    }
699  if(HHCheckIfHandleExists(fileid) == -1) {
700        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
701        return IDL_GettmpInt(NX_ERROR);
702        }
703
704  hHandle = HHGetPointer(fileid);
705  NXMSetError(NULL,idlError);
706
707  status = NXcompress (hHandle, (int) &compresstype);
708  if(status == NX_ERROR){
709        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
710        return IDL_GettmpInt(NX_ERROR);
711  }
712
713
714  return IDL_GettmpInt(status);
715}
716
717
718/*======================================================================
719 * NXmakedata
720 * status = NXmakedata (file_id, data_name, data_type, rank, dimensions[])
721 *=======================================================================*/
722
723static IDL_VPTR NXmakedata_this(int argc, IDL_VPTR *argv)
724{
725  int fileid;
726  NXhandle hHandle;
727  int iHandle, status;
728  int dimension[NX_MAXRANK], trueDimension[NX_MAXRANK], n, datatype;
729  int rank;
730  IDL_LONG *dim;
731  char* data_name;
732  char* data_type;
733  //IDL_LONG dims[IDL_MAX_ARRAY_DIM];
734
735
736  if (argc != 5) {
737        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Five arguments expected");
738        return IDL_GettmpInt(NX_ERROR);
739        }
740
741  IDL_ENSURE_SCALAR(argv[0]);
742  IDL_ENSURE_STRING(argv[1]);
743
744  IDL_ENSURE_SCALAR(argv[3]);
745
746
747  data_name = IDL_VarGetString(argv[1]);
748
749  datatype = datatypecheck(argv[2]);
750  if(datatype == -1) return IDL_GettmpInt(NX_ERROR);
751
752  fileid = (int) IDL_LongScalar(argv[0]);
753  rank = (int ) IDL_LongScalar(argv[3]);
754  if(HHCheckIfHandleExists(fileid) == -1) {
755        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
756        return IDL_GettmpInt(NX_ERROR);
757        }
758  hHandle = (int *)HHGetPointer(fileid);
759
760  NXMSetError(NULL,idlError);
761
762  if(argv[4]->type == IDL_TYP_STRING) {
763        char* unlimited_test = IDL_VarGetString(argv[4]);
764        if(strcmp(unlimited_test,"NX_UNLIMITED") == 0) {
765                int unlimited_dims[1] = {NX_UNLIMITED};
766                status = NXmakedata(hHandle, data_name, datatype, (int)rank, (int *) unlimited_dims);
767                }
768          else {
769    IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Dimension array must be type long or String: 'NX_UNLIMITED'");
770        return IDL_GettmpInt(NX_ERROR);
771        }
772  }
773  else if(argv[4]->type == IDL_TYP_LONG) {
774          IDL_ENSURE_ARRAY(argv[4]);
775          /* dimensions have to be swapped for Fortran C storage order */
776          dim = (IDL_LONG *)argv[4]->value.arr->data;
777          for(n = 0; n < rank; n++){
778            trueDimension[n] = dim[rank - 1 -n];
779          }
780          status = NXmakedata(hHandle, data_name, datatype, rank, 
781                              trueDimension);
782  }
783  else {
784    IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Dimension array must be type long or String: 'NX_UNLIMITED'");
785        return IDL_GettmpInt(NX_ERROR);
786        }
787
788  if(status == NX_ERROR){
789        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
790        return IDL_GettmpInt(NX_ERROR);
791  }
792  return IDL_GettmpInt(status);
793}
794
795
796/*======================================================================
797 * NXcompmakedata
798 * statusstatus = NXcompmakedata (file_id, data_name, data_type, rank, dimensions[], compress_type, bufsize[])
799 *=======================================================================*/
800
801static IDL_VPTR NXcompmakedata_this(int argc, IDL_VPTR *argv)
802{
803  int fileid;
804  NXhandle hHandle;
805  int iHandle, status;
806  int rank, dimension[NX_MAXRANK], trueDimension[NX_MAXRANK], 
807    trueChunk[NX_MAXRANK], n,  datatype;
808  IDL_LONG *dim;
809  int comptype;
810  char* data_type;
811  char* data_name;
812  char* comp_type;
813
814  if (argc != 7) {
815        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Seven arguments expected");
816        return IDL_GettmpInt(NX_ERROR);
817        }
818
819  IDL_ENSURE_SCALAR(argv[0]);
820  IDL_ENSURE_STRING(argv[1]);
821
822  IDL_ENSURE_SCALAR(argv[3]);
823  IDL_ENSURE_ARRAY(argv[4]);
824  IDL_ENSURE_STRING(argv[5]);
825  IDL_ENSURE_ARRAY(argv[6]);
826
827  data_name = IDL_VarGetString(argv[1]);
828
829  datatype = datatypecheck(argv[2]);
830  if(datatype == -1) return IDL_GettmpInt(NX_ERROR);
831
832  /* Compressio type check */
833  if(argv[5]->type == IDL_TYP_STRING) {
834  IDL_ENSURE_STRING(argv[5]);
835  comp_type = IDL_VarGetString(argv[5]);
836
837  if (strcmp(comp_type,"NX_COMP_LZW") == 0) {
838       comptype = NX_COMP_LZW;
839    } else if (strcmp(comp_type,"NX_COMP_HUF") == 0) {
840       comptype = NX_COMP_HUF;
841    } else if (strcmp(comp_type,"NX_COMP_RLE") == 0) {
842       comptype = NX_COMP_RLE;
843    } else {
844        char statusBuffer[100];
845        sprintf(statusBuffer,"Unknown Compression Type: %s", comp_type );
846        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, statusBuffer);
847        return IDL_GettmpInt(NX_ERROR);
848    }
849
850  }
851else {
852  IDL_ENSURE_SCALAR(argv[5]);
853  comptype = IDL_LongScalar(argv[5]);
854  if(datatype == NX_COMP_LZW); else if (datatype == NX_COMP_HUF); else if (datatype == NX_COMP_RLE);
855  else{
856        char statusBuffer[100];
857        sprintf(statusBuffer,"Unknown Compression Type: %i", comptype );
858        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, statusBuffer);
859        return IDL_GettmpInt(NX_ERROR);
860        }
861  }
862
863  if(argv[4]->type != IDL_TYP_LONG) {
864        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Argument 5, dimensions, Array must be type long");
865        return IDL_GettmpInt(NX_ERROR);
866  }
867
868  if(argv[6]->type != IDL_TYP_LONG) {
869        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Argument 7, Buffer Array: Array must be type long");
870        return IDL_GettmpInt(NX_ERROR);
871  }
872
873  fileid = (int ) IDL_LongScalar(argv[0]);
874  rank = (int ) IDL_LongScalar(argv[3]);
875  if(HHCheckIfHandleExists(fileid) == -1) {
876        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
877        return IDL_GettmpInt(NX_ERROR);
878        }
879 hHandle = HHGetPointer(fileid);
880
881  NXMSetError(NULL,idlError);
882
883  /* dimensions have to be swapped for Fortran C storage order */
884  dim = (IDL_LONG *)argv[4]->value.arr->data;
885  for(n = 0; n < rank; n++){
886    trueDimension[n] = dim[rank - 1 -n];
887  }
888  dim = (IDL_LONG *)argv[6]->value.arr->data;
889  if(dim != NULL){
890    for(n = 0; n < rank; n++){
891      trueChunk[n] = dim[rank - 1 -n];
892    }
893  } else {
894    for(n = 0; n < rank; n++){
895      trueChunk[n] = trueDimension[n];
896    }
897  }
898
899  status = NXcompmakedata(hHandle, data_name, datatype, (int)rank, 
900                          trueDimension, comptype, 
901                          trueChunk);
902
903  if(status == NX_ERROR){
904        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
905        return IDL_GettmpInt(NX_ERROR);
906  }
907
908  return IDL_GettmpInt(status);
909}
910
911/*======================================================================
912 * NXputdata
913 * status = NXputdata (file_id, data[])
914 *=======================================================================*/
915
916static IDL_VPTR NXputdata_this(int argc, IDL_VPTR *argv)
917{
918  int fileid;
919  NXhandle hHandle;
920  int iHandle, status;
921  int rank, datatype;
922  int dimension[IDL_MAX_ARRAY_DIM];
923  NXlink data_id;
924
925  fileid = (int)IDL_LongScalar(argv[0]);
926
927  if(HHCheckIfHandleExists(fileid) == -1) {
928        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
929        return IDL_GettmpInt(NX_ERROR);
930        }
931
932  IDL_ENSURE_SCALAR(argv[0]);
933  hHandle = HHGetPointer(fileid);
934
935  if (argc != 2) {
936        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Two arguments expected");
937        return IDL_GettmpInt(NX_ERROR);
938        }
939
940  status = NXgetdataID (hHandle, &data_id);
941/*  if(status == NX_ERROR) {
942                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Dataset must be opened before nxputdata");
943                return IDL_GettmpInt(NX_ERROR);
944                } */
945
946 /* get info, datatype especially! */
947    status = NXgetinfo (hHandle, &rank, dimension, &datatype);
948    if(status == NX_ERROR) {
949                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Can't get the dimension and datatype info from The Nexus file");
950                return IDL_GettmpInt(NX_ERROR);
951        }
952
953        /* Check if the IDL datatypes and Nexusdatatypes match */
954
955    if ((datatype == NX_CHAR) && (argv[1]->type == IDL_TYP_STRING)) {
956    } else if ((datatype == NX_INT8) && (argv[1]->type == IDL_TYP_BYTE)) {
957        /*       This datatype cannot be created on the idl side so it cannot be an argument.  */
958
959        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NX_INT8: data type is not supported in IDL");
960                return IDL_GettmpInt(NX_ERROR);
961        } else if (datatype == NX_UINT8){
962    } else if ((datatype == NX_INT16) && (argv[1]->type == IDL_TYP_INT)) {
963    } else if ((datatype == NX_UINT16) && (argv[1]->type == IDL_TYP_UINT)) {
964    } else if ((datatype == NX_INT32) && (argv[1]->type == IDL_TYP_LONG)) {
965    } else if ((datatype == NX_UINT32) && (argv[1]->type == IDL_TYP_ULONG))  {
966    } else if ((datatype == NX_FLOAT32) && (argv[1]->type == IDL_TYP_FLOAT)) {
967    } else if ((datatype == NX_FLOAT64) && (argv[1]->type == IDL_TYP_DOUBLE)) {
968    } else {
969                char statusBuffer[100];
970                /* Maybe print more information to the user about which datatypes match OR do conversions */
971                sprintf(statusBuffer,"IDL and NeXus types don't match!");
972                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, statusBuffer);
973                return IDL_GettmpInt(NX_ERROR);
974    }
975
976
977  NXMSetError(NULL,idlError);
978  if(datatype == NX_CHAR) {
979
980        /* Should there be a test here for trying to put a multidimensinal char array in to NeXus
981         * becose they are not really supported */
982
983          char* char_buffer = IDL_VarGetString(argv[1]);
984          status = NXputdata (hHandle, char_buffer);
985  }
986  else {
987          status = NXputdata (hHandle, argv[1]->value.arr->data);
988  }
989
990  if(status == NX_ERROR){
991        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
992        return IDL_GettmpInt(NX_ERROR);
993  }
994
995
996  return IDL_GettmpInt(status);
997}
998
999/*======================================================================
1000 * NXputslab
1001 * statusstatus = NXputslab (file_id, data, start[], size[])
1002 *=======================================================================*/
1003
1004static IDL_VPTR NXputslab_this(int argc, IDL_VPTR *argv)
1005{
1006  int fileid;
1007  NXhandle hHandle;
1008  int iHandle, status;
1009  int rank, datatype, n;
1010  int start[NX_MAXRANK], size[NX_MAXRANK];
1011  IDL_LONG *stDim, *szDim;
1012  int dimension[IDL_MAX_ARRAY_DIM];
1013  NXlink data_id;
1014
1015  if (argc != 4) {
1016        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Four arguments expected");
1017        return IDL_GettmpInt(NX_ERROR);
1018        }
1019
1020
1021  fileid = (int)IDL_LongScalar(argv[0]);
1022
1023  if(HHCheckIfHandleExists(fileid) == -1) {
1024        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
1025        return IDL_GettmpInt(NX_ERROR);
1026        }
1027
1028  IDL_ENSURE_SCALAR(argv[0]);
1029  IDL_ENSURE_ARRAY(argv[2]);
1030  IDL_ENSURE_ARRAY(argv[3]);
1031
1032  if(argv[2]->type != IDL_TYP_LONG) {
1033        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Array must be type long");
1034        return IDL_GettmpInt(NX_ERROR);
1035  }
1036
1037  if(argv[3]->type != IDL_TYP_LONG) {
1038        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Array must be type long");
1039        return IDL_GettmpInt(NX_ERROR);
1040  }
1041
1042  hHandle = HHGetPointer(fileid);
1043
1044  status = NXgetdataID (hHandle, &data_id);
1045/* if(status == NX_ERROR) {
1046                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Dataset must be opened before nxputdata");
1047                return IDL_GettmpInt(NX_ERROR);
1048                } */
1049
1050 /* get info, datatype especially! */
1051    status = NXgetinfo (hHandle, &rank, dimension, &datatype);
1052    if(status == NX_ERROR) {
1053                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Can't get the dimension and datatype info from The Nexus file");
1054                return IDL_GettmpInt(NX_ERROR);
1055        }
1056        /* Check if the IDL datatypes and Nexusdatatypes match */
1057
1058    if ((datatype == NX_CHAR) && (argv[1]->type == IDL_TYP_STRING)) {
1059    } else if ((datatype == NX_INT8) && (argv[1]->type == IDL_TYP_BYTE)) {
1060        /*
1061       } else if (datatype == NX_UINT8){
1062         This datatype cannot be created on the idl side so it cannot be an argument.
1063     */
1064    } else if ((datatype == NX_INT16) && (argv[1]->type == IDL_TYP_INT)) {
1065    } else if ((datatype == NX_UINT16) && (argv[1]->type == IDL_TYP_UINT)) {
1066    } else if ((datatype == NX_INT32) && (argv[1]->type == IDL_TYP_LONG)) {
1067    } else if ((datatype == NX_UINT32) && (argv[1]->type == IDL_TYP_ULONG))  {
1068    } else if ((datatype == NX_FLOAT32) && (argv[1]->type == IDL_TYP_FLOAT)) {
1069    } else if ((datatype == NX_FLOAT64) && (argv[1]->type == IDL_TYP_DOUBLE)) {
1070    } else {
1071                char statusBuffer[100];
1072                /* Maybe print more information to the user about which datatypes match OR do conversions */
1073                sprintf(statusBuffer,"IDL and NeXus types don't match!: %i & %i ", 
1074                        datatype, argv[1]->type);
1075                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, statusBuffer);
1076                return IDL_GettmpInt(NX_ERROR);
1077    }
1078
1079  NXMSetError(NULL,idlError);
1080
1081  if(datatype == NX_CHAR) {
1082
1083        /* Should there be a test here for trying to put a multidimensinal char array in to NeXus
1084         * becose they are not really supported */
1085
1086        char* char_buffer = IDL_VarGetString(argv[1]);
1087        status = NXputslab (hHandle, char_buffer, (void *)argv[2]->value.arr->data, (void *)argv[3]->value.arr->data);
1088
1089  }
1090  else {
1091    stDim = (IDL_LONG *) argv[2]->value.arr->data;
1092    szDim = (IDL_LONG *) argv[3]->value.arr->data;
1093    for(n = 0; n < rank; n++){
1094      start[n] = stDim[rank -n -1];
1095      size[n] = szDim[rank -n -1];
1096    }
1097                status = NXputslab (hHandle, argv[1]->value.arr->data, 
1098                                    start, size);
1099
1100  }
1101
1102  if(status == NX_ERROR){
1103        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1104        return IDL_GettmpInt(NX_ERROR);
1105  }
1106
1107  return IDL_GettmpInt(status);
1108}
1109/*======================================================================
1110 * NXputattr
1111 * status = NXputattr (file_id, attr_name, value, length, type)
1112 *=======================================================================*/
1113
1114static IDL_VPTR NXputattr_this(int argc, IDL_VPTR *argv)
1115{
1116  int fileid;
1117  NXhandle hHandle;
1118  int iHandle, status;
1119  int length, attr_type;
1120  long value_long;
1121  char* attr_name;
1122  char* attrtype;
1123
1124  void *value;
1125  if (argc != 5) {
1126        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Five arguments expected");
1127        return IDL_GettmpInt(NX_ERROR);
1128        }
1129
1130  IDL_ENSURE_SCALAR(argv[0]);
1131  IDL_ENSURE_STRING(argv[1]);
1132  IDL_ENSURE_SIMPLE(argv[2]);
1133/*  IDL_ENSURE_SCALAR(argv[3]); */
1134
1135   attr_name = IDL_VarGetString(argv[1]);
1136   length = IDL_LongScalar(argv[3]);
1137
1138   fileid = (int) IDL_LongScalar(argv[0]);
1139
1140  if(HHCheckIfHandleExists(fileid) == -1) {
1141        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
1142        return IDL_GettmpInt(NX_ERROR);
1143        }
1144
1145   hHandle = HHGetPointer(fileid);
1146
1147
1148  attr_type = datatypecheck(argv[4]);
1149  if(attr_type == -1) return IDL_GettmpInt(NX_ERROR);
1150
1151  NXMSetError(NULL,idlError);
1152
1153    if ((attr_type == NX_CHAR) && (argv[2]->type == IDL_TYP_STRING)) {
1154                attr_type = NX_CHAR;
1155                IDL_ENSURE_STRING(argv[2]);
1156                value = IDL_VarGetString(argv[2]);
1157                status = NXputattr (hHandle, attr_name, value, length, attr_type);
1158
1159    } else if ((attr_type == NX_INT8) && (argv[2]->type == IDL_TYP_INT)) {
1160                short *value_short;
1161                attr_type = NX_INT8;
1162                IDL_ENSURE_SCALAR(argv[2]);
1163                value_short = (short *) IDL_LongScalar(argv[2]);
1164                status = NXputattr (hHandle, attr_name, &value_short, length, attr_type);
1165
1166    } else if ((attr_type == NX_UINT8) && (argv[2]->type == IDL_TYP_BYTE)) {
1167        UCHAR *value_uchar;
1168                attr_type = NX_UINT8;
1169        IDL_ENSURE_SCALAR(argv[2]);
1170                value_uchar = (UCHAR *) IDL_LongScalar(argv[2]);
1171                status = NXputattr (hHandle, attr_name, &value_uchar, length, attr_type);
1172
1173    } else if ((attr_type == NX_INT16) && (argv[2]->type == IDL_TYP_INT)) {
1174                IDL_INT *value_short;
1175                attr_type = NX_INT16;
1176                IDL_ENSURE_SCALAR(argv[2]);
1177                value_short = (IDL_INT *) IDL_LongScalar(argv[2]);
1178                status = NXputattr (hHandle, attr_name, &value_short, length, attr_type);
1179
1180    } else if ((attr_type == NX_UINT16) && (argv[2]->type == IDL_TYP_UINT)) {
1181        IDL_UINT *value_uint;
1182                attr_type = NX_UINT16;
1183        IDL_ENSURE_SCALAR(argv[2]);
1184                value_uint = (IDL_UINT *) IDL_LongScalar(argv[2]);
1185                status = NXputattr (hHandle, attr_name, &value_uint, length, attr_type);
1186
1187    } else if ((attr_type == NX_INT32) && (argv[2]->type == IDL_TYP_LONG)) {
1188                IDL_LONG *value_int;
1189                attr_type = NX_INT32;
1190                IDL_ENSURE_SCALAR(argv[2]);
1191                value_int = (IDL_LONG *)IDL_LongScalar(argv[2]);
1192                status = NXputattr (hHandle, attr_name, &value_int, length, attr_type);
1193
1194    } else if ((attr_type == NX_UINT32) && (argv[2]->type == IDL_TYP_ULONG)) {
1195                IDL_ULONG *value_uint;
1196                attr_type = NX_UINT32;
1197                IDL_ENSURE_SCALAR(argv[2]);
1198                value_uint = (IDL_ULONG *) IDL_LongScalar(argv[2]);
1199                status = NXputattr (hHandle, attr_name, &value_uint, length, attr_type);
1200
1201    } else if ((attr_type == NX_FLOAT32) && (argv[2]->type == IDL_TYP_FLOAT)) {
1202                float value_float;
1203                attr_type = NX_FLOAT32;
1204        IDL_ENSURE_SCALAR(argv[2]);
1205                value_float =  IDL_DoubleScalar(argv[2]);
1206                status = NXputattr (hHandle, attr_name, &value_float, length, attr_type);
1207
1208    } else if ((attr_type == NX_FLOAT64) && (argv[2]->type == IDL_TYP_DOUBLE)) {
1209                double value_double;
1210                attr_type = NX_FLOAT64;
1211                IDL_ENSURE_SCALAR(argv[2]);
1212                value_double =  IDL_DoubleScalar(argv[2]);
1213                status = NXputattr (hHandle, attr_name, &value_double, length, attr_type);
1214
1215    } else {
1216
1217    char statusBuffer[100];
1218        sprintf(statusBuffer,"Attribute type type doesn't match with the NeXus type: %i", attr_type );
1219        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, statusBuffer);
1220        return IDL_GettmpInt(NX_ERROR);
1221    }
1222
1223  if(status == NX_ERROR){
1224        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1225        return IDL_GettmpInt(NX_ERROR);
1226  }
1227
1228
1229  return IDL_GettmpInt(status);
1230}
1231
1232/*======================================================================
1233 * NXgetattr
1234 * status = NXgetattr (file_id, attr_name, value, length, type)
1235 *=======================================================================*/
1236
1237static IDL_VPTR NXgetattr_this(int argc, IDL_VPTR *argv)
1238{
1239  int fileid;
1240  NXhandle hHandle;
1241  int iHandle, status = 1;
1242  int length, attr_type;
1243  IDL_LONG dims[IDL_MAX_ARRAY_DIM];
1244  IDL_VPTR r_value = 0, r_lenght;
1245  char* attr_name;
1246  char* attrtype;
1247  char* value_str;
1248  void *value;
1249
1250  if (argc != 5) {
1251        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Five arguments expected");
1252        return IDL_GettmpInt(NX_ERROR);
1253        }
1254  IDL_ENSURE_SCALAR(argv[0]);
1255  IDL_ENSURE_STRING(argv[1]);
1256  IDL_ENSURE_SIMPLE(argv[3]);
1257  IDL_ENSURE_SCALAR(argv[3]);
1258
1259  if (argv[3]->type != IDL_TYP_LONG) {
1260        if(argv[3]->type != IDL_TYP_INT) {
1261                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Long or Int type argument required in lenght");
1262                return IDL_GettmpInt(NX_ERROR);
1263                }
1264  }
1265
1266/*  IDL_ENSURE_STRING(argv[4]); */
1267  IDL_ENSURE_SCALAR(argv[4]);
1268
1269   attr_name = IDL_VarGetString(argv[1]);
1270
1271  attr_type = datatypecheck(argv[4]);
1272
1273  if(attr_type == -1) return IDL_GettmpInt(NX_ERROR);
1274
1275  fileid = (int) IDL_LongScalar(argv[0]);
1276  length = (int ) IDL_LongScalar(argv[3]);
1277
1278
1279  if(HHCheckIfHandleExists(fileid) == -1) {
1280        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
1281        return IDL_GettmpInt(NX_ERROR);
1282        }
1283  hHandle = HHGetPointer(fileid);
1284
1285  NXMSetError(NULL,idlError);
1286
1287   if(attr_type == NX_CHAR) {
1288
1289                length++; /* Add space for string termination */
1290                NXmalloc((void**)&value_str, 1, &length, attr_type);
1291                status = NXgetattr (hHandle, attr_name, value_str, &length, &attr_type);
1292                if(status == NX_ERROR){
1293                        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1294                        return IDL_GettmpInt(NX_ERROR);
1295            }
1296                r_value = IDL_StrToSTRING(value_str);
1297                NXfree((void**)&value_str);
1298        }
1299   else if(attr_type == NX_INT8) {
1300                IDL_INT value_int;
1301                /* There is no equivalent of this datatype in the IDL side
1302                   returning type Int */
1303
1304                status = NXgetattr (hHandle, attr_name, &value_int, &length, &attr_type);
1305                if(status == NX_ERROR){
1306                        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1307                        return IDL_GettmpInt(NX_ERROR);
1308            }
1309                r_value = IDL_GettmpUInt(value_int);
1310        }
1311   else if(attr_type == NX_UINT8) {
1312                UCHAR value_uchar;
1313                status = NXgetattr (hHandle, attr_name, &value_uchar, &length, &attr_type);
1314                if(status == NX_ERROR){
1315                        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1316                        return IDL_GettmpInt(NX_ERROR);
1317            }
1318                /* Why a warning?
1319                 * Gives a warning in gcc and doesn't compile in ms. visual c
1320                 * r_value = IDL_GettmpUChar(value_uchar); Return type int.
1321                 */
1322
1323                r_value = IDL_GettmpInt(value_uchar);
1324        }
1325   else if(attr_type == NX_INT16) {
1326                IDL_INT value_int;
1327                status = NXgetattr (hHandle, attr_name, &value_int, &length, &attr_type);
1328                if(status == NX_ERROR){
1329                        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1330                        return IDL_GettmpInt(NX_ERROR);
1331            }
1332                r_value = IDL_GettmpInt(value_int);
1333        }
1334   else if(attr_type == NX_UINT16) {
1335                IDL_UINT value_uint;
1336                status = NXgetattr (hHandle, attr_name, &value_uint, &length, &attr_type);
1337                if(status == NX_ERROR){
1338                        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1339                        return IDL_GettmpInt(NX_ERROR);
1340            }
1341                r_value = IDL_GettmpUInt(value_uint);
1342        }
1343   else if(attr_type == NX_INT32) {
1344                IDL_LONG value_long;
1345                status = NXgetattr (hHandle, attr_name, &value_long, &length, &attr_type);
1346                if(status == NX_ERROR){
1347                        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1348                        return IDL_GettmpInt(NX_ERROR);
1349            }
1350                r_value = IDL_GettmpLong(value_long);
1351        }
1352   else if(attr_type == NX_UINT32) {
1353                IDL_ULONG value_ulong;
1354                status = NXgetattr (hHandle, attr_name, &value_ulong, &length, &attr_type);
1355                if(status == NX_ERROR){
1356                        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1357                        return IDL_GettmpInt(NX_ERROR);
1358            }
1359                r_value = IDL_GettmpULong(value_ulong);
1360        }
1361   else if(attr_type == NX_FLOAT32) {
1362                float value_float;
1363                status = NXgetattr (hHandle, attr_name, &value_float, &length, &attr_type);
1364                if(status == NX_ERROR){
1365                        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1366                        return IDL_GettmpInt(NX_ERROR);
1367            }
1368                r_value = IDL_Gettmp();
1369                r_value->type = IDL_TYP_FLOAT;
1370                r_value->value.f = value_float;
1371
1372        }
1373   else if(attr_type == NX_FLOAT64) {
1374                double value_double;
1375                status = NXgetattr (hHandle, attr_name,  &value_double, &length, &attr_type);
1376                if(status == NX_ERROR){
1377                        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1378                        return IDL_GettmpInt(NX_ERROR);
1379            }
1380                r_value = IDL_Gettmp();
1381                r_value->type = IDL_TYP_DOUBLE;
1382                r_value->value.d = value_double;
1383        }
1384
1385
1386  r_lenght = IDL_GettmpInt((IDL_INT)length);
1387  IDL_VarCopy(r_value, argv[2]);
1388  IDL_VarCopy(r_lenght, argv[3]);
1389
1390  return IDL_GettmpInt(status);
1391}
1392
1393void releaseMemory( UCHAR * memPtr)
1394{
1395//      free(memPtr);
1396}
1397
1398/*======================================================================
1399 * NXgetinfo
1400 * status =  (file_id, rank, dimensions[], data_type)
1401 *
1402 *=======================================================================*/
1403
1404static IDL_VPTR NXgetinfo_this(int argc, IDL_VPTR *argv)
1405{
1406  IDL_VPTR r_rank, r_datatype, array;
1407  IDL_INT fileid;
1408  NXhandle hHandle;
1409  int iHandle, status, n;
1410  int rank,  datatype;
1411  int dimension[IDL_MAX_ARRAY_DIM];
1412  NXlink data_id;
1413  IDL_MEMINT dims[] = {IDL_MAX_ARRAY_DIM};
1414  IDL_INT *data_area_pointer;
1415
1416
1417  if (argc != 4) {
1418        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Four arguments expected");
1419        return IDL_GettmpInt(NX_ERROR);
1420        }
1421
1422  IDL_ENSURE_SCALAR(argv[0]);
1423
1424  fileid = (int) IDL_LongScalar(argv[0]);
1425  if(HHCheckIfHandleExists(fileid) == -1) {
1426        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
1427        return IDL_GettmpInt(NX_ERROR);
1428        }
1429
1430  hHandle = HHGetPointer(fileid);
1431
1432/*  status = NXgetdataID (hHandle, &data_id);
1433  if(status == NX_ERROR) {
1434                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Dataset must be opened before nxinfo");
1435                return IDL_GettmpInt(NX_ERROR);
1436          } */
1437
1438  NXMSetError(NULL,idlError);
1439
1440  status = NXgetinfo (hHandle, &rank, dimension, &datatype);
1441  if(status == NX_ERROR){
1442        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1443        return IDL_GettmpInt(NX_ERROR);
1444  }
1445
1446
1447  r_datatype = IDL_GettmpInt((IDL_INT)datatype);
1448  r_rank = IDL_GettmpInt((IDL_INT)rank);
1449
1450/*IDL_MakeTempArray returns the data area pointer as its value. Last argument 'array' is the IDL_VPTR of array */
1451
1452  data_area_pointer = (IDL_INT *)IDL_MakeTempArray((int)IDL_TYP_INT, 1, dims, IDL_ARR_INI_ZERO, &array);
1453
1454  /* Dimensions are reversed to switch from C's Column major order to IDL row major order */
1455  for(n = 0; n < rank; n++) {
1456        data_area_pointer[n] = dimension[(rank-1)-n];
1457        }
1458
1459//data_area_pointer[0] = (IDL_INT)55;
1460//*data_area_pointer = *number;
1461//  malloc(data_area_pointer, array->value.arr->arr_len);
1462
1463//  memcpy(data_area_pointer, dimension, sizeof(int));
1464
1465  // Output arguments
1466  IDL_VarCopy(r_rank, argv[1]);
1467  IDL_VarCopy(array, argv[2]);
1468  IDL_VarCopy(r_datatype, argv[3]);
1469//  releaseMemory(number);
1470
1471  return IDL_GettmpInt(status);
1472}
1473
1474/*======================================================================
1475 * NXgetgroupinfo
1476 * status = NXgetgroupinfo (file_id, item_number, group_name, group_class)
1477 *=======================================================================*/
1478
1479static IDL_VPTR NXgetgroupinfo_this(int argc, IDL_VPTR *argv)
1480{
1481  IDL_VPTR IDL_group_name, IDL_group_class, IDL_item_number;
1482  IDL_INT fileid;
1483  NXhandle hHandle;
1484  int iHandle, status;
1485  int item_number;
1486
1487/* Of the top of my head: 100.. What is the actual maximum lenght*/
1488  char group_name[100];
1489  char group_class[100];
1490
1491  if (argc != 4) {
1492        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Four arguments expected");
1493        return IDL_GettmpInt(NX_ERROR);
1494        }
1495
1496  IDL_ENSURE_SCALAR(argv[0]);
1497
1498  fileid = (int) IDL_LongScalar(argv[0]);
1499  if(HHCheckIfHandleExists(fileid) == -1) {
1500        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
1501        return IDL_GettmpInt(NX_ERROR);
1502        }
1503  hHandle = HHGetPointer(fileid);
1504
1505  NXMSetError(NULL,idlError);
1506
1507  status = NXgetgroupinfo(hHandle, &item_number, group_name, group_class);
1508  if(status == NX_ERROR){
1509        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1510        return IDL_GettmpInt(NX_ERROR);
1511  }
1512
1513  IDL_item_number = IDL_GettmpInt((IDL_INT)item_number);
1514
1515  IDL_group_name = IDL_StrToSTRING(group_name);
1516  IDL_group_class = IDL_StrToSTRING(group_class);
1517
1518  /* Output arguments */
1519  IDL_VarCopy(IDL_item_number, argv[1]);
1520  IDL_VarCopy(IDL_group_name, argv[2]);
1521  IDL_VarCopy(IDL_group_class, argv[3]);
1522
1523  return IDL_GettmpInt(status);
1524}
1525/*======================================================================
1526 * NXinitgroupdir
1527 * status = NXinitgroupdir (file_id)
1528 * Not tested at all yet..
1529 *=======================================================================*/
1530
1531static IDL_VPTR NXinitgroupdir_this(int argc, IDL_VPTR *argv)
1532{
1533  IDL_INT fileid;
1534  NXhandle hHandle;
1535  int iHandle, status;
1536
1537  if (argc != 1) {
1538        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "One argument expected");
1539        return IDL_GettmpInt(NX_ERROR);
1540        }
1541
1542  IDL_ENSURE_SCALAR(argv[0]);
1543
1544  fileid = (int) IDL_LongScalar(argv[0]);
1545  if(HHCheckIfHandleExists(fileid) == -1) {
1546        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
1547        return IDL_GettmpInt(NX_ERROR);
1548        }
1549  hHandle = HHGetPointer(fileid);
1550
1551  NXMSetError(NULL,idlError);
1552
1553  status = NXinitgroupdir(hHandle);
1554  if(status == NX_ERROR){
1555        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1556        return IDL_GettmpInt(NX_ERROR);
1557  }
1558
1559  return IDL_GettmpInt(status);
1560}
1561
1562
1563/*======================================================================
1564 * NXgetnextentry
1565 * status = NXgetnextentry (file_id, name, class, data_type)
1566 *=======================================================================*/
1567
1568static IDL_VPTR NXgetnextentry_this(int argc, IDL_VPTR *argv)
1569{
1570  IDL_VPTR IDL_group_name, IDL_group_class, IDL_data_type;
1571  IDL_INT fileid;
1572  NXhandle hHandle;
1573  int iHandle, status;
1574
1575/* Too long or long enough*/
1576  char group_name[255];
1577  char group_class[255];
1578  int data_type = 0;
1579
1580  if (argc != 4) {
1581        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Four arguments expected");
1582        return IDL_GettmpInt(NX_ERROR);
1583        }
1584
1585  IDL_ENSURE_SCALAR(argv[0]);
1586
1587  fileid = (int) IDL_LongScalar(argv[0]);
1588  if(HHCheckIfHandleExists(fileid) == -1) {
1589        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
1590        return IDL_GettmpInt(NX_ERROR);
1591        }
1592  hHandle = HHGetPointer(fileid);
1593
1594
1595  NXMSetError(NULL,idlError);
1596
1597  status = NXgetnextentry(hHandle, group_name, group_class, &data_type);
1598  if(status == NX_ERROR){
1599        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1600        return IDL_GettmpInt(NX_ERROR);
1601  }
1602
1603  IDL_data_type = IDL_GettmpInt((IDL_INT)data_type);
1604
1605  IDL_group_name = IDL_StrToSTRING(group_name);
1606  IDL_group_class = IDL_StrToSTRING(group_class);
1607
1608  /* Output arguments*/
1609  IDL_VarCopy(IDL_group_name, argv[1]);
1610  IDL_VarCopy(IDL_group_class, argv[2]);
1611  IDL_VarCopy(IDL_data_type, argv[3]);
1612
1613  return IDL_GettmpInt(status);
1614}
1615
1616/*======================================================================
1617 * NXgetattrinfo
1618 * status = NXgetattrinfo (file_id, attr_number)
1619 *=======================================================================*/
1620
1621static IDL_VPTR NXgetattrinfo_this(int argc, IDL_VPTR *argv)
1622{
1623  IDL_VPTR IDL_attr_number;
1624  IDL_INT fileid;
1625  NXhandle hHandle;
1626  int iHandle, status;
1627  int attr_number = 0;
1628
1629  if (argc != 2) {
1630        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Two arguments expected");
1631        return IDL_GettmpInt(NX_ERROR);
1632        }
1633
1634  IDL_ENSURE_SCALAR(argv[0]);
1635
1636  fileid = (int) IDL_LongScalar(argv[0]);
1637  if(HHCheckIfHandleExists(fileid) == -1) {
1638        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
1639        return IDL_GettmpInt(NX_ERROR);
1640        }
1641  hHandle = HHGetPointer(fileid);
1642
1643  NXMSetError(NULL,idlError);
1644
1645  status = NXgetattrinfo (hHandle, &attr_number);
1646  if(status == NX_ERROR){
1647        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1648        return IDL_GettmpInt(NX_ERROR);
1649  }
1650
1651  IDL_attr_number = IDL_GettmpInt((IDL_INT)attr_number);
1652
1653  /* Output arguments*/
1654  IDL_VarCopy(IDL_attr_number, argv[1]);
1655
1656  return IDL_GettmpInt(status);
1657}
1658/*======================================================================
1659 * NXinitattrdir
1660 * status = NXinitattrdir (file_id)
1661 *=======================================================================*/
1662
1663static IDL_VPTR NXinitattrdir_this(int argc, IDL_VPTR *argv)
1664{
1665  IDL_INT fileid;
1666  NXhandle hHandle;
1667  int iHandle, status;
1668
1669  if (argc != 1) {
1670        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "One arguments expected");
1671        return IDL_GettmpInt(NX_ERROR);
1672        }
1673
1674  IDL_ENSURE_SCALAR(argv[0]);
1675
1676  fileid = (int) IDL_LongScalar(argv[0]);
1677  if(HHCheckIfHandleExists(fileid) == -1) {
1678        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
1679        return IDL_GettmpInt(NX_ERROR);
1680        }
1681  hHandle = HHGetPointer(fileid);
1682
1683
1684  NXMSetError(NULL,idlError);
1685
1686  status = NXinitattrdir (hHandle);
1687  if(status == NX_ERROR){
1688        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1689        return IDL_GettmpInt(NX_ERROR);
1690  }
1691
1692  return IDL_GettmpInt(status);
1693}
1694
1695
1696/*======================================================================
1697 * NXgetnextattr
1698 * status = NXgetnextattr (file_id, attr_name, length, attr_type)
1699 *=======================================================================*/
1700
1701static IDL_VPTR NXgetnextattr_this(int argc, IDL_VPTR *argv)
1702{
1703  IDL_VPTR IDL_attr_name = NULL, IDL_length= NULL, IDL_attr_type = NULL;
1704  IDL_INT fileid;
1705  NXhandle hHandle;
1706  int iHandle, status;
1707
1708/* Too long or long enough*/
1709  char attr_name[150];
1710  int length = 0;
1711  int attr_type = 0;
1712
1713  if (argc != 4) {
1714        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Four arguments expected");
1715        return IDL_GettmpInt(NX_ERROR);
1716        }
1717
1718  IDL_ENSURE_SCALAR(argv[0]);
1719
1720  fileid = (int) IDL_LongScalar(argv[0]);
1721  if(HHCheckIfHandleExists(fileid) == -1) {
1722        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
1723        return IDL_GettmpInt(NX_ERROR);
1724        }
1725  hHandle = HHGetPointer(fileid);
1726
1727  NXMSetError(NULL,idlError);
1728
1729  status = NXgetnextattr (hHandle, attr_name, &length, &attr_type);
1730
1731  if(status == NX_ERROR){
1732        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1733        return IDL_GettmpInt(NX_ERROR);
1734  }
1735  if(status == NX_EOD) {
1736          IDL_attr_name = IDL_StrToSTRING("");
1737          IDL_length = IDL_GettmpInt((IDL_INT)0);
1738          IDL_attr_type = IDL_GettmpInt((IDL_INT)0);
1739
1740  }
1741
1742  if(status == NX_OK) {
1743  IDL_attr_name = IDL_StrToSTRING(attr_name);
1744  IDL_length = IDL_GettmpInt((IDL_INT)length);
1745  IDL_attr_type = IDL_GettmpInt((IDL_INT)attr_type);
1746  }
1747
1748  /* Output arguments*/
1749  IDL_VarCopy(IDL_attr_name, argv[1]);
1750  IDL_VarCopy(IDL_length, argv[2]);
1751  IDL_VarCopy(IDL_attr_type, argv[3]);
1752  return IDL_GettmpInt(status);
1753}
1754
1755
1756/*======================================================================
1757 * NXgetgroupID
1758 * statusstatus = NXgetgroupID (file_id, group_id)
1759 *======================================================================*/
1760static IDL_VPTR NXgetgroupID_this(int argc, IDL_VPTR *argv)
1761{
1762  IDL_VPTR result;
1763  int status, iHandle, iLink;
1764  NXaccess am;
1765  int fileid;
1766  NXhandle hHandle;
1767  NXlink *group_id = NULL;
1768
1769  /* If number of arguments is not 2 return status NX_ERROR */
1770  if (argc != 2) {
1771        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Two arguments expected");
1772        return IDL_GettmpInt(NX_ERROR);
1773        }
1774
1775  IDL_ENSURE_SCALAR(argv[0]);
1776
1777  fileid = (int) IDL_LongScalar(argv[0]);
1778  if(HHCheckIfHandleExists(fileid) == -1) {
1779        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
1780        return IDL_GettmpInt(NX_ERROR);
1781        }
1782
1783  hHandle = HHGetPointer(fileid);
1784
1785  group_id = (NXlink *)malloc(sizeof(NXlink));
1786  if(group_id == NULL){
1787        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unable to allocate memory for the group id link file");
1788        return IDL_GettmpInt(NX_ERROR);
1789  }
1790
1791  NXMSetError(NULL,idlError);
1792
1793  status = NXgetgroupID (hHandle, group_id);
1794  if(status == NX_ERROR){
1795        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1796        return IDL_GettmpInt(NX_ERROR);
1797  }
1798
1799
1800  iLink = HHMakeLinkHandle(group_id, fileid);
1801     if(iLink == -1) {
1802        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Error creating the link handle");
1803                return IDL_GettmpInt(NX_ERROR);
1804        }
1805
1806  result = IDL_GettmpInt(iLink);
1807
1808  // Output argument
1809  IDL_VarCopy(result, argv[1]);
1810
1811  return IDL_GettmpInt(status);
1812}
1813
1814
1815/*======================================================================
1816 * NXgetdataID
1817 * status = NXgetdataID (file_id, data_id)
1818 *======================================================================*/
1819static IDL_VPTR NXgetdataID_this(int argc, IDL_VPTR *argv)
1820{
1821  IDL_VPTR result;
1822  int status, iHandle, iLink;
1823  NXaccess am;
1824  int fileid;
1825  NXhandle hHandle;
1826  NXlink *data_id = NULL;
1827
1828  /* If number of arguments is not 2 return status NX_ERROR */
1829  if (argc != 2) {
1830        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Two arguments expected");
1831        return IDL_GettmpInt(NX_ERROR);
1832        }
1833
1834  IDL_ENSURE_SCALAR(argv[0]);
1835
1836  fileid = (int) IDL_LongScalar(argv[0]);
1837  if(HHCheckIfHandleExists(fileid) == -1) {
1838        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
1839        return IDL_GettmpInt(NX_ERROR);
1840        }
1841
1842  hHandle = HHGetPointer(fileid);
1843
1844  data_id = (NXlink *)malloc(sizeof(NXlink));
1845  if(data_id == NULL){
1846        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unable to allocate memory for the data id link file");
1847        return IDL_GettmpInt(NX_ERROR);
1848  }
1849
1850  NXMSetError(NULL,idlError);
1851
1852  status = NXgetdataID (hHandle, data_id);
1853
1854  if(status == NX_ERROR){
1855        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1856        return IDL_GettmpInt(NX_ERROR);
1857  }
1858
1859  iLink = HHMakeLinkHandle(data_id, fileid);
1860
1861    if(iLink == -1) {
1862        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Error creating the link handle");
1863                return IDL_GettmpInt(NX_ERROR);
1864        }
1865
1866  result = IDL_GettmpInt(iLink);
1867
1868  // Output argument
1869  IDL_VarCopy(result, argv[1]);
1870
1871  return IDL_GettmpInt(status);
1872}
1873
1874/*======================================================================
1875 * NXgetdata
1876 * status = NXgetdata (file_id, data)
1877 *=======================================================================*/
1878
1879static IDL_VPTR NXgetdata_this(int argc, IDL_VPTR *argv)
1880{
1881  IDL_VPTR data_array;
1882  int fileid;
1883  NXhandle hHandle;
1884  int iHandle, status;
1885  int rank,  datatype, n;
1886/*int dimension[IDL_MAX_ARRAY_DIM]; */
1887/*  int dimension[8]; */
1888  IDL_ARRAY_DIM dimension;
1889  int data_area_pointer[NX_MAXRANK];
1890  void *data_buffer = NULL;
1891  char *char_buffer;
1892  NXlink data_id;
1893
1894
1895  if (argc != 2) {
1896        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Two arguments expected");
1897        return IDL_GettmpInt(NX_ERROR);
1898        }
1899
1900  IDL_ENSURE_SCALAR(argv[0]);
1901
1902  fileid = (int ) IDL_LongScalar(argv[0]);
1903  if(HHCheckIfHandleExists(fileid) == -1) {
1904        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
1905        return IDL_GettmpInt(NX_ERROR);
1906        }
1907
1908
1909  hHandle = HHGetPointer(fileid);
1910
1911/*  status = NXgetdataID (hHandle, &data_id);
1912  if(status == NX_ERROR) {
1913                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Dataset must be opened before nxputdata");
1914                return IDL_GettmpInt(NX_ERROR);
1915                } */
1916
1917  NXMSetError(NULL,idlError);
1918
1919  /* First get the rank, dimension and datatype */
1920  status = NXgetinfo (hHandle, &rank, data_area_pointer, &datatype);
1921  if(status == NX_ERROR) {
1922        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1923        return IDL_GettmpInt(NX_ERROR);
1924        }
1925  /* Dimensions are reversed to switch from C's Column major order to IDL row major order */
1926  for(n = 0; n < rank; n++) {
1927        dimension[n] = data_area_pointer[rank - 1 -n];
1928        }
1929
1930/* Check data type and prepare a Array or a String for NeXuS API nxgetdata function*/
1931   switch (datatype) {
1932        case NX_CHAR:
1933                /*IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXCHAR");*/
1934
1935        break;
1936        case NX_FLOAT32:
1937                /*IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXFLOAT32");*/
1938                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_FLOAT, rank, dimension, IDL_ARR_INI_ZERO, &data_array);
1939        break;
1940        case NX_FLOAT64:
1941                /*IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXFLOAT64");*/
1942                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_DOUBLE, rank, dimension, IDL_ARR_INI_ZERO, &data_array);
1943        break;
1944        case NX_INT8:
1945                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "This data type is not supported in IDL");
1946//              return IDL_GettmpInt(NX_ERROR);
1947                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_BYTE, rank, dimension, IDL_ARR_INI_ZERO, &data_array);
1948                /* This data type is not supported in IDL, A dangerous conversion to IDL_TYP_INT? */
1949        break;
1950        case NX_UINT8:
1951                /*      IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXUINT8"); */
1952                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_BYTE, rank, dimension, IDL_ARR_INI_ZERO, &data_array);
1953        break;
1954        case NX_INT16:
1955                /*IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXINT16"); */
1956                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_INT, rank, dimension, IDL_ARR_INI_ZERO, &data_array);
1957        break;
1958        case NX_UINT16:
1959                /*IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXINT16"); */
1960                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_UINT, rank, dimension, IDL_ARR_INI_ZERO, &data_array);
1961        break;
1962        case NX_INT32:
1963                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXINT32");
1964                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_LONG, rank, dimension, IDL_ARR_INI_ZERO, &data_array);
1965        break;
1966        case NX_UINT32:
1967                /*IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXUINT32");*/
1968                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_ULONG, rank, dimension, IDL_ARR_INI_ZERO, &data_array);
1969        break;
1970        default:
1971                /*IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Data is of an unknown datatype");*/
1972                return IDL_GettmpInt(NX_ERROR);
1973        break;
1974        }
1975
1976  NXMSetError(NULL,idlError);
1977
1978if(datatype == NX_CHAR) {
1979        status =  NXmalloc ((void **) &char_buffer, rank, data_area_pointer, 
1980                            datatype);
1981        if(status == NX_ERROR){
1982                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1983                return IDL_GettmpInt(NX_ERROR);
1984                }
1985
1986        status = NXgetdata (hHandle, char_buffer);
1987        if(status == NX_ERROR){
1988                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
1989                return IDL_GettmpInt(NX_ERROR);
1990                }
1991        data_array = IDL_StrToSTRING(char_buffer);
1992        IDL_VarCopy(data_array, argv[1]);
1993        NXfree((void **) &char_buffer);
1994   }
1995else {
1996
1997        status = NXgetdata (hHandle, data_buffer);
1998        if(status == NX_ERROR){
1999                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2000                return IDL_GettmpInt(NX_ERROR);
2001        }
2002
2003   IDL_VarCopy(data_array, argv[1]);
2004
2005   }
2006
2007/* For temporary variables VarCopy copies the dynamic part to destination, not the actual data.
2008 * So not really slower and a lot safer than writing the data straight to argv[1].
2009 *
2010 *External Development Guide: IDL Internals: Variables
2011 * Copying Variables:
2012 *If the source is a temporary variable, IDL_VarCopy() does not make a duplicate of the dynamic
2013 *part for the destination. Instead, the dynamic part of the source is given to the destination,
2014 *and the source variable itself is returned to the pool of free temporary variables. This is the
2015 *equivalent of freeing the temporary variable. Therefore, the variable must not be used any
2016 *further and the caller should not explicitly free the variable. This optimization significantly
2017 *improves resource utilization and performance because this special case occurs frequently.
2018 */
2019
2020  return IDL_GettmpInt(status);
2021}
2022/*======================================================================
2023 * NXgetslab
2024 * status = NXgetslab (file_id, data, start[], size[])
2025 *=======================================================================*/
2026
2027static IDL_VPTR NXgetslab_this(int argc, IDL_VPTR *argv)
2028{
2029  IDL_VPTR data_array;
2030  int fileid;
2031  NXhandle hHandle;
2032  int iHandle, status;
2033  int rank,  datatype, n;
2034  IDL_MEMINT start[NX_MAXRANK], size[NX_MAXRANK], dim[NX_MAXRANK];
2035  int istart[NX_MAXRANK], isize[NX_MAXRANK];
2036  IDL_LONG *stDim, *szDim;
2037  IDL_ARRAY_DIM dimension;
2038  void *data_buffer = NULL;
2039
2040
2041  if (argc != 4) {
2042        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Four arguments expected");
2043        return IDL_GettmpInt(NX_ERROR);
2044        }
2045
2046  IDL_ENSURE_SCALAR(argv[0]);
2047  IDL_ENSURE_ARRAY(argv[2]);
2048  IDL_ENSURE_ARRAY(argv[3]);
2049
2050  /*Check that the arrays are type long */
2051
2052  if(argv[2]->type != IDL_TYP_LONG) {
2053        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Argument 3, slap start, Array must be type long");
2054        return IDL_GettmpInt(NX_ERROR);
2055  }
2056
2057  if(argv[3]->type != IDL_TYP_LONG) {
2058        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Argument 4, slap size: Array must be type long");
2059        return IDL_GettmpInt(NX_ERROR);
2060  }
2061
2062  fileid = (int) IDL_LongScalar(argv[0]);
2063  if(HHCheckIfHandleExists(fileid) == -1) {
2064        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
2065        return IDL_GettmpInt(NX_ERROR);
2066        }
2067
2068  hHandle = HHGetPointer(fileid);
2069
2070/*  status = NXgetdataID (hHandle, &data_id);
2071  if(status == NX_ERROR) {
2072                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Dataset must be opened before nxputdata");
2073                return IDL_GettmpInt(NX_ERROR);
2074              } */
2075
2076  /* First get the rank, dimension and datatype */
2077  status = NXgetinfo (hHandle, &rank, dim, &datatype);
2078  if(status == NX_ERROR) {
2079        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2080        return IDL_GettmpInt(NX_ERROR);
2081        }
2082
2083  /* swap dimensions again */
2084  stDim = (IDL_LONG *)argv[2]->value.arr->data;
2085  szDim = (IDL_LONG *)argv[3]->value.arr->data;
2086  for(n = 0; n < rank; n++){
2087    start[n] = stDim[rank -n  -1];
2088    istart[n] = stDim[rank -n  -1];
2089    size[n] = szDim[rank -n  -1];
2090    isize[n] = szDim[rank -n  -1];
2091  }
2092
2093
2094/* Check data type and prepare a Array or a String for NeXuS API nxgetdata function*/
2095   switch (datatype) {
2096        case NX_CHAR:
2097                /* IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXCHAR"); */
2098
2099        break;
2100        case NX_FLOAT32:
2101                /* IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXFLOAT32"); */
2102                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_FLOAT, rank, (void *)size, IDL_ARR_INI_ZERO, &data_array);
2103        break;
2104        case NX_FLOAT64:
2105                /* IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXFLOAT64"); */
2106                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_DOUBLE, rank, (void *) size, IDL_ARR_INI_ZERO, &data_array);
2107        break;
2108        case NX_INT8:
2109                /* This data type is not supported in IDL, A dangerous conversion to IDL_TYP_INT? */
2110                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_BYTE, rank, (void *)size, IDL_ARR_INI_ZERO, &data_array);
2111        break;
2112        case NX_UINT8:
2113                /* IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXUINT8"); */
2114                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_BYTE, rank, (void *)size, IDL_ARR_INI_ZERO, &data_array);
2115        break;
2116        case NX_INT16:
2117                /* IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXINT16"); */
2118                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_INT, rank, (void *)size, IDL_ARR_INI_ZERO, &data_array);
2119        break;
2120        case NX_UINT16:
2121                /* IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXUINT16"); */
2122                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_UINT, rank, (void *)size, IDL_ARR_INI_ZERO, &data_array);
2123        break;
2124        case NX_INT32:
2125                /* IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXINT32"); */
2126                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_LONG, rank, (void *)size, IDL_ARR_INI_ZERO, &data_array);
2127
2128        break;
2129        case NX_UINT32:
2130                /* IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NXUINT32"); */
2131                data_buffer = (void *)IDL_MakeTempArray(IDL_TYP_ULONG, rank, (void *)size, IDL_ARR_INI_ZERO, &data_array);
2132        break;
2133        default:
2134                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Data in the NeXus file is of an unknown datatype");
2135                return IDL_GettmpInt(NX_ERROR);
2136        break;
2137        }
2138
2139  NXMSetError(NULL,idlError);
2140
2141   if(datatype == NX_CHAR) {
2142        /* Api doesnt support getslab for textdata!
2143         *
2144         * Currently The C Api returns the correct string slab put mixes something up badly
2145         * and program crashes at some point.
2146         * */
2147
2148        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "NeXus IDL API doesn't support textdata for getslab ");
2149        return IDL_GettmpInt(NX_ERROR);
2150
2151/*      char* char_buffer;
2152
2153        status =  NXmalloc ((void **) &char_buffer, rank, argv[3]->value.arr->data, datatype);
2154    if(status == NX_ERROR){
2155                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2156                return IDL_GettmpInt(NX_ERROR);
2157        }
2158
2159        status = NXgetslab (hHandle, char_buffer, (int *) argv[2]->value.arr->data, (int *) argv[3]->value.arr->data);
2160         if(status == NX_ERROR){
2161                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2162                return IDL_GettmpInt(NX_ERROR);
2163        }
2164
2165        IDL_char_data = IDL_StrToSTRING(char_buffer);
2166        IDL_VarCopy(IDL_char_data, argv[1]);
2167        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Debug 3 zz");
2168
2169    if(status == NX_ERROR){
2170                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2171                return IDL_GettmpInt(NX_ERROR);
2172        }
2173*/
2174     }
2175
2176  else {
2177          status = NXgetslab (hHandle, data_buffer, istart, isize);
2178          if(status == NX_ERROR)
2179                {
2180                IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2181                return IDL_GettmpInt(NX_ERROR);
2182        }
2183          IDL_VarCopy(data_array, argv[1]);
2184   }
2185
2186  return IDL_GettmpInt(status);
2187}
2188
2189/*======================================================================
2190 * NXflush
2191 * status = NXflush (file_id)
2192 *======================================================================*/
2193static IDL_VPTR NXflush_this(int argc, IDL_VPTR *argv)
2194{
2195  IDL_VPTR result;
2196  int status, iHandle;
2197  NXaccess am;
2198  int fileid;
2199  NXhandle hHandle;
2200
2201  /* If number of arguments is not 1 return status NX_ERROR */
2202  if (argc != 1) {
2203        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "One argument expected");
2204        return IDL_GettmpInt(NX_ERROR);
2205        }
2206
2207  IDL_ENSURE_SCALAR(argv[0]);
2208
2209  fileid = (int) IDL_LongScalar(argv[0]);
2210  if(HHCheckIfHandleExists(fileid) == -1) {
2211        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
2212        return IDL_GettmpInt(NX_ERROR);
2213        }
2214
2215  hHandle = HHGetPointer(fileid);
2216
2217
2218  NXMSetError(NULL,idlError);
2219
2220  status = NXflush (&hHandle);
2221  if(status == NX_ERROR){
2222        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2223        return IDL_GettmpInt(NX_ERROR);
2224  }
2225
2226/* We don't loose the links with HHChangeHandle */
2227  HHChangeHandle(hHandle, fileid);
2228
2229  result = IDL_GettmpLong(fileid);
2230
2231  // Output argument
2232  IDL_VarCopy(result, argv[0]);
2233
2234  return IDL_GettmpInt(status);
2235}
2236
2237
2238/*======================================================================
2239 * Nxinquirefile
2240 * status = NXinquirefile(handle,filename, filenameLength)
2241 *=======================================================================*/
2242
2243static IDL_VPTR NXinquirefile_this(int argc, IDL_VPTR *argv)
2244{
2245  IDL_VPTR IDL_filename;
2246  IDL_INT fileid;
2247  NXhandle hHandle;
2248  int iHandle, status;
2249
2250/* Max file name lenght in mac os, unix, linux, windows */
2251  char filename[254];
2252  int filenameLength;
2253
2254  if (argc != 3) {
2255        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Three arguments expected");
2256        return IDL_GettmpInt(NX_ERROR);
2257        }
2258
2259  IDL_ENSURE_SCALAR(argv[0]);
2260  IDL_ENSURE_SCALAR(argv[2]);
2261
2262  fileid = (int) IDL_LongScalar(argv[0]);
2263  filenameLength =  IDL_LongScalar(argv[2]);
2264
2265  if(HHCheckIfHandleExists(fileid) == -1) {
2266        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
2267        return IDL_GettmpInt(NX_ERROR);
2268        }
2269  hHandle = HHGetPointer(fileid);
2270
2271  NXMSetError(NULL,idlError);
2272
2273  status = NXinquirefile(hHandle, filename, filenameLength);
2274  if(status == NX_ERROR){
2275        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2276        return IDL_GettmpInt(NX_ERROR);
2277  }
2278
2279  IDL_filename = IDL_StrToSTRING(filename);
2280
2281  /* Output arguments*/
2282  IDL_VarCopy(IDL_filename, argv[1]);
2283
2284  return IDL_GettmpInt(status);
2285}
2286
2287
2288/*======================================================================
2289 * NXmakelink
2290 * status = NXmakelink (file_id, link)
2291 *======================================================================*/
2292static IDL_VPTR NXmakelink_this(int argc, IDL_VPTR *argv)
2293{
2294  int status, iHandle, iLink;
2295  NXaccess am;
2296  int fileid, linkid;
2297  NXhandle hHandle;
2298  NXlink *link;
2299
2300  /* If number of arguments is not 2 return status NX_ERROR */
2301  if (argc != 2) {
2302        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Two arguments expected");
2303        return IDL_GettmpInt(NX_ERROR);
2304        }
2305
2306  IDL_ENSURE_SCALAR(argv[0]);
2307
2308  fileid = (int) IDL_LongScalar(argv[0]);
2309
2310  if(HHCheckIfHandleExists(fileid) == -1) {
2311        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
2312        return IDL_GettmpInt(NX_ERROR);
2313        }
2314  hHandle = HHGetPointer(fileid);
2315
2316  linkid = (int) IDL_LongScalar(argv[1]);
2317
2318  if(HHCheckIfHandleExists(linkid) == -1) {
2319        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown link id");
2320        return IDL_GettmpInt(NX_ERROR);
2321        }
2322  link = (NXlink *)HHGetPointer(linkid);
2323
2324  NXMSetError(NULL,idlError);
2325
2326  status = NXmakelink (hHandle, link);
2327  if(status == NX_ERROR){
2328        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2329        return IDL_GettmpInt(NX_ERROR);
2330  }
2331
2332/* Commented, No output arguments in makelink
2333
2334  iLink = HHMakeHandle(link);
2335
2336  result = IDL_GettmpInt(iLink);
2337
2338  // Output argument
2339  IDL_VarCopy(result, argv[1]); */
2340
2341  return IDL_GettmpInt(status);
2342}
2343
2344
2345/*======================================================================
2346 * NXmakenamedlink
2347 * status = NXmakenamedlink (file_id, nameoflink, link)
2348 *======================================================================*/
2349static IDL_VPTR NXmakenamedlink_this(int argc, IDL_VPTR *argv)
2350{
2351
2352  int status, iHandle, iLink;
2353  NXaccess am;
2354  int fileid, linkid;
2355  NXhandle hHandle;
2356  NXlink *link;
2357  char* nameoflink;
2358
2359  /* If number of arguments is not 3 return status NX_ERROR */
2360  if (argc != 3) {
2361        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Three arguments expected");
2362        return IDL_GettmpInt(NX_ERROR);
2363        }
2364
2365  IDL_ENSURE_SCALAR(argv[0]);
2366  IDL_ENSURE_STRING(argv[1]);
2367  IDL_ENSURE_SCALAR(argv[2]);
2368  fileid = (int) IDL_LongScalar(argv[0]);
2369  nameoflink = IDL_VarGetString(argv[1]);
2370  if(HHCheckIfHandleExists(fileid) == -1) {
2371        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
2372        return IDL_GettmpInt(NX_ERROR);
2373        }
2374  hHandle = HHGetPointer(fileid);
2375
2376  linkid = (int) IDL_LongScalar(argv[2]);
2377
2378  if(HHCheckIfHandleExists(linkid) == -1) {
2379        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown link id");
2380        return IDL_GettmpInt(NX_ERROR);
2381        }
2382  link = (NXlink *)HHGetPointer(linkid);
2383
2384  NXMSetError(NULL,idlError);
2385
2386  status = NXmakenamedlink (hHandle, nameoflink, link);
2387  if(status == NX_ERROR){
2388        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2389        return IDL_GettmpInt(NX_ERROR);
2390  }
2391
2392  return IDL_GettmpInt(status);
2393}
2394
2395/*======================================================================
2396 * NXlinkexternal
2397 * status = NXlinkexternal(handle, name, nxclass, nxurl)
2398 *=======================================================================*/
2399
2400static IDL_VPTR NXlinkexternal_this(int argc, IDL_VPTR *argv)
2401{
2402  int fileid;
2403  NXhandle hHandle;
2404  int iHandle, status;
2405  char* name;
2406  char* nxclass;
2407  char* nxurl;
2408
2409  if (argc != 4) {
2410        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Three arguments expected");
2411        return IDL_GettmpInt(NX_ERROR);
2412        }
2413
2414  IDL_ENSURE_SCALAR(argv[0]);
2415  IDL_ENSURE_STRING(argv[1]);
2416  IDL_ENSURE_STRING(argv[2]);
2417  IDL_ENSURE_STRING(argv[3]);
2418
2419  fileid = (int)IDL_LongScalar(argv[0]);
2420  name = IDL_VarGetString(argv[1]);
2421  nxclass = IDL_VarGetString(argv[2]);
2422  nxurl = IDL_VarGetString(argv[3]);
2423
2424
2425  if(HHCheckIfHandleExists(fileid) == -1) {
2426        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
2427        return IDL_GettmpInt(NX_ERROR);
2428        }
2429
2430  hHandle = HHGetPointer(fileid);
2431
2432  NXMSetError(NULL,idlError);
2433
2434  status = NXlinkexternal(hHandle, name, nxclass, nxurl);
2435  if(status == NX_ERROR){
2436        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2437        return IDL_GettmpInt(NX_ERROR);
2438  }
2439
2440
2441  return IDL_GettmpInt(status);
2442}
2443
2444
2445/*======================================================================
2446 * NXisexternalgroup
2447 * status = NXisexternalgroup(handle,name, nxclass, nxurl, nxurllen)
2448 *=======================================================================*/
2449
2450static IDL_VPTR NXisexternalgroup_this(int argc, IDL_VPTR *argv)
2451{
2452  IDL_VPTR IDL_NXurl;
2453  int fileid;
2454  NXhandle hHandle;
2455  int iHandle, status;
2456  int nxurllen;
2457  char* name;
2458  char* nxclass;
2459  char* nxurl;
2460  if (argc != 5) {
2461        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Five arguments expected");
2462        return IDL_GettmpInt(NX_ERROR);
2463        }
2464
2465  IDL_ENSURE_SCALAR(argv[0]);
2466  IDL_ENSURE_STRING(argv[1]);
2467  IDL_ENSURE_STRING(argv[2]);
2468  IDL_ENSURE_SCALAR(argv[4]);
2469
2470  fileid = (int )IDL_LongScalar(argv[0]);
2471  name = IDL_VarGetString(argv[1]);
2472  nxclass = IDL_VarGetString(argv[2]);
2473  nxurllen =  IDL_LongScalar(argv[4]);
2474
2475                nxurllen++; /* Add space for string termination */
2476                status = NXmalloc((void**)&nxurl, 1, &nxurllen, NX_CHAR);
2477                if(status == NX_ERROR){
2478                        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2479                        return IDL_GettmpInt(NX_ERROR);
2480                }
2481
2482
2483
2484
2485  if(HHCheckIfHandleExists(fileid) == -1) {
2486        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
2487        return IDL_GettmpInt(NX_ERROR);
2488        }
2489
2490  hHandle = HHGetPointer(fileid);
2491
2492  NXMSetError(NULL,idlError);
2493
2494  status = NXisexternalgroup(hHandle, name, nxclass, nxurl, nxurllen);
2495
2496  NXfree((void**)&nxurl);
2497
2498  if(status == NX_ERROR){
2499        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2500        IDL_NXurl = IDL_StrToSTRING("");
2501        IDL_VarCopy(IDL_NXurl, argv[3]);
2502        return IDL_GettmpInt(NX_ERROR);
2503  }
2504
2505  IDL_NXurl = IDL_StrToSTRING(nxurl);
2506
2507  /* Output arguments*/
2508  IDL_VarCopy(IDL_NXurl, argv[3]);
2509
2510  return IDL_GettmpInt(status);
2511}
2512
2513/*======================================================================
2514 * NXsameID
2515 * status = NXsameID (file_id, link1, link2)
2516 *======================================================================*/
2517static IDL_VPTR NXsameID_this(int argc, IDL_VPTR *argv)
2518{
2519
2520
2521  int status, iHandle, iLink;
2522  NXaccess am;
2523  int fileid, linkid_one, linkid_two;
2524  NXhandle hHandle;
2525  NXlink *link_one, *link_two;
2526
2527  if (argc != 3) {
2528        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Three arguments expected");
2529        return IDL_GettmpInt(NX_ERROR);
2530        }
2531
2532  IDL_ENSURE_SCALAR(argv[0]);
2533  IDL_ENSURE_SCALAR(argv[1]);
2534  IDL_ENSURE_SCALAR(argv[2]);
2535
2536  fileid = (int ) IDL_LongScalar(argv[0]);
2537  linkid_one = (int ) IDL_LongScalar(argv[1]);
2538  linkid_two = (int ) IDL_LongScalar(argv[2]);
2539
2540  if(HHCheckIfHandleExists(fileid) == -1) {
2541        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Unknown file id");
2542        return IDL_GettmpInt(NX_ERROR);
2543        }
2544  hHandle = HHGetPointer(fileid);
2545
2546
2547  if(HHCheckIfHandleExists(linkid_one) == -1) {
2548        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Argument 2, Unknown link id");
2549        return IDL_GettmpInt(NX_ERROR);
2550        }
2551
2552  link_one = (NXlink *)HHGetPointer(linkid_one);
2553
2554  if(HHCheckIfHandleExists(linkid_two) == -1) {
2555        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, "Argument 3, Unknown link id");
2556        return IDL_GettmpInt(NX_ERROR);
2557        }
2558
2559  link_two = (NXlink *)HHGetPointer(linkid_two);
2560
2561  NXMSetError(NULL,idlError);
2562
2563  status = NXsameID (hHandle, link_one, link_two);
2564  if(status == NX_ERROR){
2565        IDL_Message(IDL_M_NAMED_GENERIC, IDL_MSG_INFO, nexusError);
2566        return IDL_GettmpInt(NX_ERROR);
2567  }
2568
2569  return IDL_GettmpInt(1);
2570
2571}
2572
2573
2574int IDL_Load(void)
2575{
2576  /*
2577   * These tables contain information on the functions and procedures
2578   * that make up the NeXusIDL-API DLM. The information contained in these
2579   * tables must be identical to that contained in NeXusIDL-API.dlm.
2580   */
2581  static IDL_SYSFUN_DEF2 function_addr[] = {
2582    { NXopen_this, "NXOPEN", 0, IDL_MAXPARAMS, 0, 0},
2583    { NXclose_this, "NXCLOSE", 0, IDL_MAXPARAMS, 0, 0},
2584    { NXsetnumberformat_this, "NXSETNUMBERFORMAT", 0, IDL_MAXPARAMS, 0, 0},
2585    { NXopenpath_this, "NXOPENPATH", 0, IDL_MAXPARAMS, 0, 0},
2586    { NXopengrouppath_this, "NXOPENGROUPPATH", 0, IDL_MAXPARAMS, 0, 0},
2587    { NXgetpath_this, "NXGETPATH", 0, IDL_MAXPARAMS, 0, 0},
2588    { NXmakegroup_this, "NXMAKEGROUP", 0, IDL_MAXPARAMS, 0, 0},
2589    { NXopengroup_this, "NXOPENGROUP", 0, IDL_MAXPARAMS, 0, 0},
2590        { NXcompress_this, "NXCOMPRESS", 0, IDL_MAXPARAMS, 0, 0},
2591    { NXclosegroup_this, "NXCLOSEGROUP", 0, IDL_MAXPARAMS, 0, 0},
2592    { NXmakedata_this, "NXMAKEDATA", 0, IDL_MAXPARAMS, 0, 0},
2593    { NXcompmakedata_this, "NXCOMPMAKEDATA", 0, IDL_MAXPARAMS, 0, 0},
2594    { NXputdata_this, "NXPUTDATA", 0, IDL_MAXPARAMS, 0, 0},
2595    { NXputslab_this, "NXPUTSLAB", 0, IDL_MAXPARAMS, 0, 0},
2596    { NXputattr_this, "NXPUTATTR", 0, IDL_MAXPARAMS, 0, 0},
2597    { NXgetattr_this, "NXGETATTR", 0, IDL_MAXPARAMS, 0, 0},
2598    { NXgetinfo_this, "NXGETINFO", 0, IDL_MAXPARAMS, 0, 0},
2599    { NXgetgroupinfo_this, "NXGETGROUPINFO", 0, IDL_MAXPARAMS, 0, 0},
2600    { NXinitgroupdir_this, "NXINITGROUPDIR", 0, IDL_MAXPARAMS, 0, 0},
2601    { NXgetnextentry_this, "NXGETNEXTENTRY", 0, IDL_MAXPARAMS, 0, 0},
2602    { NXinitattrdir_this, "NXINITATTRDIR", 0, IDL_MAXPARAMS, 0, 0},
2603    { NXgetattrinfo_this, "NXGETATTRINFO", 0, IDL_MAXPARAMS, 0, 0},
2604    { NXgetnextattr_this, "NXGETNEXTATTR", 0, IDL_MAXPARAMS, 0, 0},
2605    { NXgetgroupID_this, "NXGETGROUPID", 0, IDL_MAXPARAMS, 0, 0},
2606    { NXgetdataID_this, "NXGETDATAID", 0, IDL_MAXPARAMS, 0, 0},
2607    { NXopendata_this, "NXOPENDATA", 0, IDL_MAXPARAMS, 0, 0},
2608    { NXclosedata_this, "NXCLOSEDATA", 0, IDL_MAXPARAMS, 0, 0},
2609    { NXgetdata_this, "NXGETDATA", 0, IDL_MAXPARAMS, 0, 0},
2610    { NXgetslab_this, "NXGETSLAB", 0, IDL_MAXPARAMS, 0, 0},
2611    { NXflush_this, "NXFLUSH", 0, IDL_MAXPARAMS, 0, 0},
2612    { NXinquirefile_this, "NXINQUIREFILE", 0, IDL_MAXPARAMS, 0, 0},
2613    { NXmakelink_this, "NXMAKELINK", 0, IDL_MAXPARAMS, 0, 0},
2614    { NXmakenamedlink_this, "NXMAKENAMEDLINK", 0, IDL_MAXPARAMS, 0, 0},
2615    { NXlinkexternal_this, "NXLINKEXTERNAL", 0, IDL_MAXPARAMS, 0, 0},
2616    { NXisexternalgroup_this, "NXISEXTERNALGROUP", 0, IDL_MAXPARAMS, 0, 0},
2617    { NXsameID_this, "NXSAMEID", 0, IDL_MAXPARAMS, 0, 0}
2618  };
2619
2620  /*
2621   * Create a message block to hold our messages. Save its handle where
2622   * the other routines can access it.
2623   */
2624  if (!(msg_block = IDL_MessageDefineBlock("NeXusIDL-API",
2625                                           IDL_CARRAY_ELTS(msg_arr), msg_arr)))
2626    return IDL_FALSE;
2627
2628  /*
2629   * Register our routine. The routines must be specified exactly the same
2630   * as in NeXusIDL-API.dlm.
2631   */
2632
2633   IDL_SysRtnAdd(function_addr, TRUE, IDL_CARRAY_ELTS(function_addr));
2634
2635   return IDL_TRUE;
2636}
Note: See TracBrowser for help on using the repository browser.