source: trunk/src/fortran/RpLibraryFStubs.c @ 591

Last change on this file since 591 was 591, checked in by dkearney, 14 years ago

Added putFile capability to octave, matlab, fortran, perl bindings
Adjusted the core putFile function and all put functions to accept unsigned ints
added enum flags for binary and text file for the putFile function in c/c++

File size: 19.0 KB
Line 
1/*
2 * ----------------------------------------------------------------------
3 *  INTERFACE: Fortran Rappture Library Stub Functions
4 *
5 * ======================================================================
6 *  AUTHOR:  Derrick Kearney, Purdue University
7 *  Copyright (c) 2004-2007  Purdue Research Foundation
8 *
9 *  See the file "license.terms" for information on usage and
10 *  redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
11 * ======================================================================
12 */
13#ifdef __cplusplus
14    extern "C" {
15#endif
16
17
18/**********************************************************/
19
20int
21rp_lib_ ( const char* filePath, int filePath_len ) {
22    return rp_lib (filePath,filePath_len);
23}
24
25int
26rp_lib__ ( const char* filePath, int filePath_len ) {
27    return rp_lib (filePath,filePath_len);
28}
29
30int
31RP_LIB( const char* filePath, int filePath_len ) {
32    return rp_lib (filePath,filePath_len);
33}
34
35void
36rp_lib_element_comp_ ( int* handle,
37                       char* path,
38                       char* retText,
39                       int path_len,
40                       int retText_len ) {
41
42    return rp_lib_element_comp(handle,path,retText,path_len,retText_len);
43}
44
45void
46rp_lib_element_comp__ ( int* handle,
47                       char* path,
48                       char* retText,
49                       int path_len,
50                       int retText_len ) {
51
52    return rp_lib_element_comp(handle,path,retText,path_len,retText_len);
53}
54
55void
56RP_LIB_ELEMENT_COMP ( int* handle,
57                       char* path,
58                       char* retText,
59                       int path_len,
60                       int retText_len ) {
61
62    return rp_lib_element_comp(handle,path,retText,path_len,retText_len);
63}
64
65void
66rp_lib_element_id_ (   int* handle,
67                       char* path,
68                       char* retText,
69                       int path_len,
70                       int retText_len ) {
71
72    return rp_lib_element_id(handle,path,retText,path_len,retText_len);
73}
74
75void
76rp_lib_element_id__ (   int* handle,
77                       char* path,
78                       char* retText,
79                       int path_len,
80                       int retText_len ) {
81
82    return rp_lib_element_id(handle,path,retText,path_len,retText_len);
83}
84
85void
86RP_LIB_ELEMENT_ID (   int* handle,
87                       char* path,
88                       char* retText,
89                       int path_len,
90                       int retText_len ) {
91
92    return rp_lib_element_id(handle,path,retText,path_len,retText_len);
93}
94
95void
96rp_lib_element_type_ ( int* handle,
97                       char* path,
98                       char* retText,
99                       int path_len,
100                       int retText_len ) {
101
102    return rp_lib_element_type(handle,path,retText,path_len,retText_len);
103}
104
105void
106rp_lib_element_type__ ( int* handle,
107                       char* path,
108                       char* retText,
109                       int path_len,
110                       int retText_len ) {
111
112    return rp_lib_element_type(handle,path,retText,path_len,retText_len);
113}
114
115void
116RP_LIB_ELEMENT_TYPE  ( int* handle,
117                       char* path,
118                       char* retText,
119                       int path_len,
120                       int retText_len ) {
121
122    return rp_lib_element_type(handle,path,retText,path_len,retText_len);
123}
124
125int
126rp_lib_element_obj_ (   int* handle,
127                        char* path,
128                        int path_len ) {
129
130    return rp_lib_element_obj(handle,path,path_len);
131}
132
133int
134rp_lib_element_obj__ (   int* handle,
135                        char* path,
136                        int path_len ) {
137
138    return rp_lib_element_obj(handle,path,path_len);
139}
140
141int
142RP_LIB_ELEMENT_OBJ  (   int* handle,
143                        char* path,
144                        int path_len ) {
145
146    return rp_lib_element_obj(handle,path,path_len);
147}
148
149/*
150 * rp_lib_child_num still needs to be written
151 * keep these stub functions around
152int
153rp_lib_child_num_ (     int* handle,
154                        char* path,
155                        int* childHandle,
156                        int path_len) {
157
158    return rp_lib_child_num(handle,path,childHandle,path_len);
159}
160
161int
162rp_lib_child_num__ (     int* handle,
163                        char* path,
164                        int* childHandle,
165                        int path_len) {
166
167    return rp_lib_child_num(handle,path,childHandle,path_len);
168}
169
170int
171RP_LIB_CHILD_NUM (     int* handle,
172                        char* path,
173                        int* childHandle,
174                        int path_len) {
175
176    return rp_lib_child_num(handle,path,childHandle,path_len);
177}
178*/
179
180int
181rp_lib_children_ (     int* handle, /* integer handle of library */
182                       char* path, /* search path of the xml */
183                       int* childHandle, /*int handle of last returned child*/
184                       int path_len  /*length of the search path buffer*/
185                 ) {
186
187    return rp_lib_children(handle,path,childHandle,path_len);
188}
189
190int
191rp_lib_children__ (     int* handle, /* integer handle of library */
192                       char* path, /* search path of the xml */
193                       int* childHandle, /*int handle of last returned child*/
194                       int path_len  /*length of the search path buffer*/
195                 ) {
196
197    return rp_lib_children(handle,path,childHandle,path_len);
198}
199
200int
201RP_LIB_CHILDREN (     int* handle, /* integer handle of library */
202                       char* path, /* search path of the xml */
203                       int* childHandle, /*int handle of last returned child*/
204                       int path_len  /*length of the search path buffer*/
205                 ) {
206
207    return rp_lib_children(handle,path,childHandle,path_len);
208}
209
210void
211rp_lib_get_ (           int* handle,
212                        char* path,
213                        char* retText,
214                        int path_len,
215                        int retText_len ) {
216
217    return rp_lib_get(handle,path,retText,path_len,retText_len);
218}
219
220void
221rp_lib_get__ (           int* handle,
222                        char* path,
223                        char* retText,
224                        int path_len,
225                        int retText_len ) {
226
227    return rp_lib_get(handle,path,retText,path_len,retText_len);
228}
229
230void
231RP_LIB_GET  (           int* handle,
232                        char* path,
233                        char* retText,
234                        int path_len,
235                        int retText_len ) {
236
237    return rp_lib_get(handle,path,retText,path_len,retText_len);
238}
239
240void
241rp_lib_get_str_ (       int* handle,
242                        char* path,
243                        char* retText,
244                        int path_len,
245                        int retText_len ) {
246
247    return rp_lib_get_str(handle,path,retText,path_len,retText_len);
248}
249
250void
251rp_lib_get_str__ (      int* handle,
252                        char* path,
253                        char* retText,
254                        int path_len,
255                        int retText_len ) {
256
257    return rp_lib_get_str(handle,path,retText,path_len,retText_len);
258}
259
260void
261RP_LIB_GET_STR  (       int* handle,
262                        char* path,
263                        char* retText,
264                        int path_len,
265                        int retText_len ) {
266
267    return rp_lib_get_str(handle,path,retText,path_len,retText_len);
268}
269
270double
271rp_lib_get_double_ (    int* handle,
272                        char* path,
273                        int path_len) {
274
275    return rp_lib_get_double(handle,path,path_len);
276}
277
278double
279rp_lib_get_double__ (    int* handle,
280                        char* path,
281                        int path_len) {
282
283    return rp_lib_get_double(handle,path,path_len);
284}
285
286double
287RP_LIB_GET_DOUBLE (    int* handle,
288                        char* path,
289                        int path_len) {
290
291    return rp_lib_get_double(handle,path,path_len);
292}
293
294int
295rp_lib_get_integer_ (   int* handle,
296                        char* path,
297                        int path_len) {
298
299    return rp_lib_get_integer(handle,path,path_len);
300}
301
302int
303rp_lib_get_integer__ (  int* handle,
304                        char* path,
305                        int path_len) {
306
307    return rp_lib_get_integer(handle,path,path_len);
308}
309
310int
311RP_LIB_GET_INTEGER (    int* handle,
312                        char* path,
313                        int path_len) {
314
315    return rp_lib_get_integer(handle,path,path_len);
316}
317
318int
319rp_lib_get_boolean_ (   int* handle,
320                        char* path,
321                        int path_len) {
322
323    return rp_lib_get_boolean(handle,path,path_len);
324}
325
326int
327rp_lib_get_boolean__ (  int* handle,
328                        char* path,
329                        int path_len) {
330
331    return rp_lib_get_boolean(handle,path,path_len);
332}
333
334int
335RP_LIB_GET_BOOLEAN (    int* handle,
336                        char* path,
337                        int path_len) {
338
339    return rp_lib_get_boolean(handle,path,path_len);
340}
341
342void
343rp_lib_put_str_ (       int* handle,
344                        char* path,
345                        char* value,
346                        int* append,
347                        int path_len,
348                        int value_len ) {
349
350    rp_lib_put_str(handle,path,value,append,path_len,value_len);
351    return;
352}
353
354void
355rp_lib_put_str__ (       int* handle,
356                        char* path,
357                        char* value,
358                        int* append,
359                        int path_len,
360                        int value_len ) {
361
362    rp_lib_put_str(handle,path,value,append,path_len,value_len);
363    return;
364}
365
366void
367RP_LIB_PUT_STR (       int* handle,
368                        char* path,
369                        char* value,
370                        int* append,
371                        int path_len,
372                        int value_len ) {
373
374    rp_lib_put_str(handle,path,value,append,path_len,value_len);
375    return;
376}
377
378void
379rp_lib_put_id_str_ (    int* handle,
380                        char* path,
381                        char* value,
382                        char* id,
383                        int* append,
384                        int path_len,
385                        int value_len,
386                        int id_len ) {
387
388    rp_lib_put_id_str(handle,path,value,id,append,path_len,value_len,id_len);
389    return;
390}
391
392void
393rp_lib_put_id_str__ (    int* handle,
394                        char* path,
395                        char* value,
396                        char* id,
397                        int* append,
398                        int path_len,
399                        int value_len,
400                        int id_len ) {
401
402    rp_lib_put_id_str(handle,path,value,id,append,path_len,value_len,id_len);
403    return;
404}
405
406void
407RP_LIB_PUT_ID_STR (    int* handle,
408                        char* path,
409                        char* value,
410                        char* id,
411                        int* append,
412                        int path_len,
413                        int value_len,
414                        int id_len ) {
415
416    rp_lib_put_id_str(handle,path,value,id,append,path_len,value_len,id_len);
417    return;
418}
419
420void
421rp_lib_put_data_ (      int* handle,
422                        char* path,
423                        char* bytes,
424                        int* nbytes,
425                        int* append,
426                        int path_len,
427                        int bytes_len ) {
428
429    rp_lib_put_data(handle,path,bytes,nbytes,append,path_len,bytes_len);
430    return;
431}
432
433void
434rp_lib_put_data__ (     int* handle,
435                        char* path,
436                        char* bytes,
437                        int* nbytes,
438                        int* append,
439                        int path_len,
440                        int bytes_len ) {
441
442    rp_lib_put_data(handle,path,bytes,nbytes,append,path_len,bytes_len);
443    return;
444}
445
446void
447RP_LIB_PUT_DATA (       int* handle,
448                        char* path,
449                        char* bytes,
450                        int* nbytes,
451                        int* append,
452                        int path_len,
453                        int bytes_len ) {
454
455    rp_lib_put_data(handle,path,bytes,nbytes,append,path_len,bytes_len);
456    return;
457}
458
459void
460rp_lib_put_file_ (      int* handle,
461                        char* path,
462                        char* fileName,
463                        int* fileType,
464                        int* append,
465                        int path_len,
466                        int fileName_len ) {
467
468    rp_lib_put_file(handle,path,fileName,fileType,append,path_len,fileName_len);
469    return;
470}
471
472void
473rp_lib_put_file__ (     int* handle,
474                        char* path,
475                        char* fileName,
476                        int* fileType,
477                        int* append,
478                        int path_len,
479                        int fileName_len ) {
480
481    rp_lib_put_file(handle,path,fileName,fileType,append,path_len,fileName_len);
482    return;
483}
484
485void
486RP_LIB_PUT_FILE (       int* handle,
487                        char* path,
488                        char* fileName,
489                        int* fileType,
490                        int* append,
491                        int path_len,
492                        int fileName_len ) {
493
494    rp_lib_put_file(handle,path,fileName,fileType,append,path_len,fileName_len);
495    return;
496}
497
498/*
499 * rp_lib_put_obj still needs to be written
500 * keep these stub functions around
501void
502rp_lib_put_obj_ (       int* handle,
503                        char* path,
504                        int* valHandle,
505                        int* append,
506                        int path_len ) {
507
508    return rp_lib_put_obj(handle,path,valHandle,append,path_len);
509}
510
511void
512rp_lib_put_obj__ (       int* handle,
513                        char* path,
514                        int* valHandle,
515                        int* append,
516                        int path_len ) {
517
518    return rp_lib_put_obj(handle,path,valHandle,append,path_len);
519}
520
521void
522RP_LIB_PUT_OBJ (       int* handle,
523                        char* path,
524                        int* valHandle,
525                        int* append,
526                        int path_len ) {
527
528    return rp_lib_put_obj(handle,path,valHandle,append,path_len);
529}
530*/
531
532/*
533 * rp_lib_put_id_obj still needs to be written
534 * keep these stub functions around
535void
536rp_lib_put_id_obj_ (    int* handle,
537                        char* path,
538                        int* valHandle,
539                        char* id,
540                        int* append,
541                        int path_len,
542                        int id_len ) {
543
544    return rp_lib_put_id_obj(handle,path,valHandle,id,append,path_len,id_len);
545}
546
547void
548rp_lib_put_id_obj__ (    int* handle,
549                        char* path,
550                        int* valHandle,
551                        char* id,
552                        int* append,
553                        int path_len,
554                        int id_len ) {
555
556    return rp_lib_put_id_obj(handle,path,valHandle,id,append,path_len,id_len);
557}
558
559void
560RP_LIB_PUT_ID_OBJ (    int* handle,
561                        char* path,
562                        int* valHandle,
563                        char* id,
564                        int* append,
565                        int path_len,
566                        int id_len ) {
567
568    return rp_lib_put_id_obj(handle,path,valHandle,id,append,path_len,id_len);
569}
570*/
571
572/*
573 * rp_lib_remove still needs to be written
574 * keep these stub functions around
575int
576rp_lib_remove_ (        int* handle,
577                        char* path,
578                        int path_len) {
579
580    return rp_lib_remove(handle,path,path_len);
581}
582
583int
584rp_lib_remove__ (        int* handle,
585                        char* path,
586                        int path_len) {
587
588    return rp_lib_remove(handle,path,path_len);
589}
590
591int
592RP_LIB_REMOVE  (        int* handle,
593                        char* path,
594                        int path_len) {
595
596    return rp_lib_remove(handle,path,path_len);
597}
598*/
599
600/*
601 * rp_lib_xml_len still needs to be written
602 * keep these stub functions around
603int
604rp_lib_xml_len_(        int* handle) {
605    return rp_lib_xml_len(handle);
606}
607
608int
609rp_lib_xml_len__(        int* handle) {
610    return rp_lib_xml_len(handle);
611}
612
613int
614RP_LIB_XML_LEN (        int* handle) {
615    return rp_lib_xml_len(handle);
616}
617*/
618
619void
620rp_lib_xml_(            int* handle,
621                        char* retText,
622                        int retText_len) {
623    return rp_lib_xml(handle,retText,retText_len);
624}
625
626void
627rp_lib_xml__(            int* handle,
628                        char* retText,
629                        int retText_len) {
630    return rp_lib_xml(handle,retText,retText_len);
631}
632
633void
634RP_LIB_XML (            int* handle,
635                        char* retText,
636                        int retText_len) {
637    return rp_lib_xml(handle,retText,retText_len);
638}
639
640int
641rp_lib_write_xml_(      int* handle,
642                        char* outFile,
643                        int outFile_len) {
644    return rp_lib_write_xml (handle,outFile,outFile_len);
645}
646
647int
648rp_lib_write_xml__(      int* handle,
649                        char* outFile,
650                        int outFile_len) {
651    return rp_lib_write_xml (handle,outFile,outFile_len);
652}
653
654int
655RP_LIB_WRITE_XML(      int* handle,
656                        char* outFile,
657                        int outFile_len) {
658    return rp_lib_write_xml (handle,outFile,outFile_len);
659}
660
661void
662rp_lib_node_comp_ (     int* handle,
663                        char* retText,
664                        int retText_len) {
665    return rp_lib_node_comp (handle,retText,retText_len);
666}
667
668void
669rp_lib_node_comp__ (     int* handle,
670                        char* retText,
671                        int retText_len) {
672    return rp_lib_node_comp (handle,retText,retText_len);
673}
674
675void
676RP_LIB_NODE_COMP (     int* handle,
677                        char* retText,
678                        int retText_len) {
679    return rp_lib_node_comp (handle,retText,retText_len);
680}
681
682void
683rp_lib_node_type_ (     int* handle,
684                        char* retText,
685                        int retText_len) {
686    return rp_lib_node_type (handle,retText,retText_len);
687}
688
689void
690rp_lib_node_type__ (     int* handle,
691                        char* retText,
692                        int retText_len) {
693    return rp_lib_node_type (handle,retText,retText_len);
694}
695
696void
697RP_LIB_NODE_TYPE (      int* handle,
698                        char* retText,
699                        int retText_len) {
700    return rp_lib_node_type (handle,retText,retText_len);
701}
702
703void
704rp_lib_node_id_ (       int* handle,
705                        char* retText,
706                        int retText_len) {
707    return rp_lib_node_id(handle,retText,retText_len);
708}
709
710void
711rp_lib_node_id__ (       int* handle,
712                        char* retText,
713                        int retText_len) {
714    return rp_lib_node_id(handle,retText,retText_len);
715}
716
717void
718RP_LIB_NODE_ID (        int* handle,
719                        char* retText,
720                        int retText_len) {
721    return rp_lib_node_id(handle,retText,retText_len);
722}
723
724void
725rp_result_(             int* handle ) {
726    return rp_result(handle);
727}
728
729void
730rp_result__(             int* handle ) {
731    return rp_result(handle);
732}
733
734void
735RP_RESULT (             int* handle ) {
736    return rp_result(handle);
737}
738
739
740/**********************************************************/
741/**********************************************************/
742
743#ifdef __cplusplus
744    }
745#endif
Note: See TracBrowser for help on using the repository browser.