Debian Codegraph @

bindings/idl/NeXusIDL-API.c

raw
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 */
34 int 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 */
42 static 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 */
55 static IDL_MSG_BLOCK msg_block;
56
57 static char nexusError[1024];
58
59 static 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 *======================================================================*/
69 static 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
141 static 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
184 static 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 *======================================================================*/
224 static 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 *=======================================================================*/
260 static 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
304 int 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 }
338 else {
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
361 static 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 }
413 else {
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
450 static 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
493 static 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
539 static 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
580 static 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 *=======================================================================*/
622 static 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
671 static 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
723 static 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
801 static 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 }
851 else {
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
916 static 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
1004 static 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
1114 static 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
1237 static 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
1393 void releaseMemory( UCHAR * memPtr)
1394 {
1395 // free(memPtr);
1396 }
1397
1398 /*======================================================================
1399 * NXgetinfo
1400 * status = (file_id, rank, dimensions[], data_type)
1401 *
1402 *=======================================================================*/
1403
1404 static 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
1479 static 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
1531 static 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
1568 static 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
1621 static 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
1663 static 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
1701 static 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 *======================================================================*/
1760 static 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 *======================================================================*/
1819 static 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
1879 static 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
1978 if(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 }
1995 else {
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
2027 static 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 *======================================================================*/
2193 static 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
2243 static 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 *======================================================================*/
2292 static 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 *======================================================================*/
2349 static 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
2400 static 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
2450 static 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 *======================================================================*/
2517 static 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
2574 int 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 }