source: trunk/src/fortran/RpLibraryFInterface.cc @ 84

Last change on this file since 84 was 84, checked in by dkearney, 17 years ago
  1. added "install" target to make file for copying files over to /opt/rappture
  2. added targets for python to build and install the units module
  3. added fortran stub functions for library and units.

RpLibraryF_test.f compiles, just with warnings, because i'm still working on it.

File size: 21.6 KB
Line 
1/*
2 * ----------------------------------------------------------------------
3 *  INTERFACE: Fortran Rappture Library Source
4 *
5 * ======================================================================
6 *  AUTHOR:  Derrick Kearney, Purdue University
7 *  Copyright (c) 2005
8 *  Purdue Research Foundation, West Lafayette, IN
9 * ======================================================================
10 */
11
12#include "RpLibraryFInterface.h"
13#include "RpLibraryFStubs.c"
14
15int rp_lib(const char* filePath, int filePath_len)
16{
17    RpLibrary* lib = NULL;
18    int handle = -1;
19    std::string inFilePath = "";
20
21    inFilePath = null_terminate_str(filePath, filePath_len);
22
23    // create a RapptureIO object and store in dictionary
24    lib = new RpLibrary(inFilePath);
25
26    if (lib) {
27        handle = storeObject_Lib(lib);
28    }
29
30    return handle;
31}
32
33int rp_lib_element_obj(int* handle,     /* integer handle of library */
34                          char* path,     /* null terminated path */
35                          int path_len
36                        )
37{
38    int newObjHandle = -1;
39
40    std::string inPath = "";
41
42    RpLibrary* lib = NULL;
43    RpLibrary* retObj = NULL;
44
45    inPath = null_terminate_str(path,path_len);
46
47    if ((handle) && (*handle != 0)) {
48        lib = getObject_Lib(*handle);
49        if (lib) {
50            retObj = lib->element(inPath);
51
52            if (retObj) {
53                newObjHandle = storeObject_Lib(retObj);
54            }
55        }
56    }
57
58    return newObjHandle;
59}
60
61void rp_lib_element_comp( int* handle, /* integer handle of library */
62                            char* path,      /* null terminated path */
63                            char* retText,   /* return buffer for fortran*/
64                            int path_len,
65                            int retText_len /* length of return text buffer */
66                          )
67{
68    std::string inPath = "";
69    RpLibrary* lib = NULL;
70    std::string retStr = "";
71
72    inPath = null_terminate_str(path,path_len);
73
74    lib = getObject_Lib(*handle);
75
76    if (lib) {
77        retStr = lib->element(inPath)->nodeComp();
78        if (!retStr.empty()) {
79            fortranify(retStr.c_str(),retText,retText_len);
80        }
81    }
82
83}
84
85void rp_lib_element_id(   int* handle, /* integer handle of library */
86                            char* path,      /* null terminated path */
87                            char* retText,   /* return buffer for fortran*/
88                            int path_len,
89                            int retText_len /* length of return text buffer */
90                        )
91{
92    std::string inPath = "";
93    RpLibrary* lib = NULL;
94    std::string retStr = "";
95
96    inPath = null_terminate_str(path,path_len);
97
98    lib = getObject_Lib(*handle);
99
100    if (lib) {
101        retStr = lib->element(inPath)->nodeId();
102        if (!retStr.empty()) {
103            fortranify(retStr.c_str(),retText,retText_len);
104        }
105    }
106}
107
108void rp_lib_element_type( int* handle, /* integer handle of library */
109                            char* path,      /* search path inside xml */
110                            char* retText,   /* return buffer for fortran*/
111                            int path_len,
112                            int retText_len /* length of return text buffer */
113                          )
114{
115    std::string inPath = "";
116    RpLibrary* lib = NULL;
117    std::string retStr = "";
118
119    inPath = null_terminate_str(path,path_len);
120
121    lib = getObject_Lib(*handle);
122
123    if (lib) {
124        retStr = lib->element(inPath)->nodeType();
125        fortranify(retStr.c_str(),retText,retText_len);
126    }
127}
128
129int rp_lib_children (   int* handle, /* integer handle of library */
130                        char* path, /* search path of the xml */
131                        int* childHandle, /*integer hanlde of last returned child*/
132                        int path_len  /* length of the search path buffer */
133                    ) {
134
135    std::string inPath = "";
136    RpLibrary* lib = NULL;
137    RpLibrary* childNode = NULL;
138    int newObjHandle = -1;
139
140    inPath = null_terminate_str(path,path_len);
141
142    if (handle && (*handle >= 0) ) {
143        lib = getObject_Lib(*handle);
144        if (lib) {
145            if (*childHandle < 1) {
146                // check to see if there were any previously returned children
147                childNode = getObject_Lib(*childHandle);
148            }
149
150            // call the children base method
151            childNode = lib->children(path,childNode);
152
153            // store the childNode in the dictionary.
154            //
155            // because the base method is using static memory to get store the
156            // children we should be able to chekc and see if the childHandle
157            // was valud.
158            // if so, then we can just return the childHandle back to the user
159            // if not, store the object in the dictionary and return the new
160            // handle.
161
162            if (childNode) {
163                if (*childHandle < 1) {
164                    newObjHandle = storeObject_Lib(childNode);
165                }
166                else {
167                    newObjHandle = *childHandle;
168                }
169            }
170        }
171    }
172
173    return newObjHandle;
174
175}
176
177/*
178int rp_lib_child_num( int* handle,
179                         char* path,
180                         int path_len
181                       )
182{
183    int numChildren = 0;
184
185    PyObject* lib = NULL;
186    PyObject* list = NULL;
187    char* inPath = NULL;
188
189    inPath = null_terminate(path,path_len);
190
191    if (rapptureStarted) {
192        if ((handle) && (*handle != 0)) {
193            lib = getObject_Lib(*handle);
194
195            if (lib) {
196                list = rpChildren_f(lib, inPath, "type");
197                if (list) {
198                    numChildren = PyList_Size(list);
199                    Py_DECREF(list);
200                }
201                else {
202
203                }
204            }
205        }
206    }
207
208    if (inPath) {
209        free(inPath);
210        inPath = NULL;
211    }
212
213    return numChildren;
214
215}
216*/
217
218//int rp_lib_child_comp (   int* handle,    /* integer handle of library */
219//                            char* path,     /* DOM path of requested object */
220//                            char* type,     /* specific name of element */
221//                            int* childNum,  /* child number for iteration */
222//                            char* retText,  /* buffer to store return text */
223//                            int path_len,   /* length of path */
224//                            int type_len,   /* length of type */
225//                            int retText_len /* length of return text buffer */
226//                       )
227/*
228{
229    int retVal = 0;
230
231    char* inPath = NULL;
232    char* inType = NULL;
233
234    inPath = null_terminate(path,path_len);
235    inType = null_terminate(type,type_len);
236
237    if (inPath) {
238        path_len = strlen(inPath) + 1;
239    }
240    else {
241        path_len = 0;
242    }
243
244    if (inType) {
245        type_len = strlen(inType) + 1;
246    }
247    else {
248        type_len = 0;
249    }
250
251    retVal = rp_lib_child_str( handle,
252                                 inPath,
253                                 "component",
254                                 inType,
255                                 childNum,
256                                 retText,
257                                 path_len,
258                                 10,
259                                 type_len,
260                                 retText_len
261                               );
262
263    if (inPath) {
264        free(inPath);
265        inPath = NULL;
266    }
267
268    if (inType) {
269        free(inType);
270        inType = NULL;
271    }
272
273    return retVal;
274}
275*/
276
277//int rp_lib_child_id(   int* handle,    /* integer handle of library */
278//                          char* path,     /* DOM path of requested object */
279//                          char* type,     /* specific name of element */
280//                          int* childNum,  /* child number for iteration */
281//                          char* retText,  /* buffer to store return text */
282//                          int path_len,   /* length of path */
283//                          int type_len,   /* length of type */
284//                          int retText_len /* length of return text buffer */
285//                       )
286/*
287{
288    int retVal = 0;
289    char* inPath = NULL;
290    char* inType = NULL;
291
292    inPath = null_terminate(path,path_len);
293    inType = null_terminate(type,type_len);
294
295    if (inPath) {
296        path_len = strlen(inPath) + 1;
297    }
298    else {
299        path_len = 0;
300    }
301
302    if (inType) {
303        type_len = strlen(inType) + 1;
304    }
305    else {
306        type_len = 0;
307    }
308
309    retVal = rp_lib_child_str( handle,
310                                 inPath,
311                                 "id",
312                                 inType,
313                                 childNum,
314                                 retText,
315                                 path_len,
316                                 3,
317                                 type_len,
318                                 retText_len
319                               );
320
321    if (inPath) {
322        free(inPath);
323        inPath = NULL;
324    }
325
326    if (inType) {
327        free(inType);
328        inType = NULL;
329    }
330
331    return retVal;
332}
333*/
334
335//int rp_lib_child_type (   int* handle,    /* integer handle of library */
336//                            char* path,     /* DOM path of requested object */
337//                            char* type,     /* specific name of element */
338//                            int* childNum,  /* child number for iteration */
339//                            char* retText,  /* buffer to store return text */
340//                            int path_len,   /* length of path */
341//                            int type_len,   /* length of type */
342//                            int retText_len /* length of return text buffer */
343//                       )
344/*
345{
346    int retVal = 0;
347    char* inPath = NULL;
348    char* inType = NULL;
349
350    inPath = null_terminate(path,path_len);
351    inType = null_terminate(type,type_len);
352
353    if (inPath) {
354        path_len = strlen(inPath) + 1;
355    }
356    else {
357        path_len = 0;
358    }
359
360    if (inType) {
361        type_len = strlen(inType) + 1;
362    }
363    else {
364        type_len = 0;
365    }
366
367    retVal = rp_lib_child_str( handle,
368                                 inPath,
369                                 "type",
370                                 inType,
371                                 childNum,
372                                 retText,
373                                 path_len,
374                                 5,
375                                 type_len,
376                                 retText_len
377                               );
378
379    if (inPath) {
380        free(inPath);
381        inPath = NULL;
382    }
383
384    if (inType) {
385        free(inType);
386        inType = NULL;
387    }
388
389    return retVal;
390}
391*/
392
393/*
394int rp_lib_child_obj ( int* handle,
395                            char* path,
396                            char* type,
397                            int path_len,
398                            int type_len
399                          )
400{
401    int newObjHandle = -1;
402
403    PyObject* lib = NULL;
404    PyObject* list = NULL;
405   
406    char* inPath = NULL;
407    char* inType = NULL;
408
409    inPath = null_terminate(path,path_len);
410    inType = null_terminate(type,type_len);
411
412    if (rapptureStarted) {
413        if ((handle) && (*handle != 0)) {
414            lib = getObject_Lib(*handle);
415           
416            if (lib) {
417                list = rpChildren_f(lib, inPath, "object");
418                if (list) {
419                    // store the whole list,
420                    // need to make a way to read the nodes
421                    newObjHandle = storeObject_Lib(list);
422                    // Py_DECREF(list);
423                }
424                else {
425                   
426                }
427            }
428        }
429    }
430
431    if (inPath) {
432        free(inPath);
433        inPath = NULL;
434    }
435
436    if (inType) {
437        free(inType);
438        inType = NULL;
439    }
440
441    return newObjHandle;
442
443}
444*/
445
446void rp_lib_get( int* handle, /* integer handle of library */
447                   char* path,      /* null terminated path */
448                   char* retText,   /* return text buffer for fortran*/
449                   int path_len,
450                   int retText_len /* length of return text buffer */
451                 )
452{
453    std::string xmlText = "";
454
455    RpLibrary* lib = NULL;
456
457    std::string inPath = "";
458
459    inPath = null_terminate_str(path,path_len);
460
461    if ((handle) && (*handle != 0)) {
462        lib = getObject_Lib(*handle);
463
464        if (lib) {
465            xmlText = lib->getString(inPath);
466            if (!xmlText.empty()) {
467                fortranify(xmlText.c_str(),retText,retText_len);
468            }
469
470        }
471    }
472}
473
474double rp_lib_get_double( int* handle,   /* integer handle of library */
475                            char* path,    /* null terminated path */
476                            int path_len
477                          )
478{
479    double retVal = 0.0;
480
481    RpLibrary* lib = NULL;
482
483    std::string inPath = "";
484
485    inPath = null_terminate_str(path,path_len);
486
487    if ((handle) && (*handle != 0)) {
488        lib = getObject_Lib(*handle);
489
490        if (lib) {
491            retVal = lib->getDouble(inPath);
492        }
493    }
494
495    return retVal;
496}
497
498
499void rp_lib_put_str( int* handle,
500                        char* path,
501                        char* value,
502                        int* append,
503                        int path_len,
504                        int value_len
505                      )
506{
507    std::string inPath = "";
508    std::string inValue = "";
509    RpLibrary* lib = NULL;
510
511    inPath = null_terminate_str(path,path_len);
512    inValue = null_terminate_str(value,value_len);
513
514    if ((handle) && (*handle != 0)) {
515        lib = getObject_Lib(*handle);
516
517        if (lib) {
518            lib->put(inPath,inValue,"",*append);
519        }
520    }
521
522    return;
523
524}
525
526
527void rp_lib_put_id_str ( int* handle,
528                        char* path,
529                        char* value,
530                        char* id,
531                        int* append,
532                        int path_len,
533                        int value_len,
534                        int id_len
535                      )
536{
537    RpLibrary* lib = NULL;
538
539    std::string inPath = "";
540    std::string inValue = "";
541    std::string inId = "";
542
543    inPath = null_terminate_str(path,path_len);
544    inValue = null_terminate_str(value,value_len);
545    inId = null_terminate_str(id,id_len);
546
547    if ((handle) && (*handle != 0)) {
548        lib = getObject_Lib(*handle);
549
550        if (lib) {
551            lib->put(inPath,inValue,inId,*append);
552        }
553    }
554
555}
556
557//void rp_lib_put_obj( int* handle,
558//                        char* path,
559//                        int* valHandle,
560//                        int* append,
561//                        int path_len
562//                      )
563//{
564//    std::string inPath = "";
565//    RpLibrary* lib = NULL;
566//
567//    // inPath = null_terminate(path,path_len);
568//    inPath = std::string(path,path_len);
569//
570//    /*
571//    if (inPath) {
572//        path_len = strlen(inPath) + 1;
573//    }
574//    */
575//
576//    if ((handle) && (*handle != 0)) {
577//        lib = getObject_Lib(*handle);
578//       
579//        if (lib) {
580//            // rpPut(lib, inPath, inValue, inId, *append);
581//            lib->put(inPath,inValue,"",*append);
582//        }
583//    }
584//
585//    /*
586//    rp_lib_put_id_obj(handle,inPath,valHandle,NULL,append,path_len,0);
587//
588//    if (inPath) {
589//        free(inPath);
590//        inPath = NULL;
591//    }
592//    */
593//
594//}
595
596/*
597void rp_lib_put_id_obj ( int* handle,
598                        char* path,
599                        int* valHandle,
600                        char* id,
601                        int* append,
602                        int path_len,
603                        int id_len
604                      )
605{
606    PyObject* lib = NULL;
607    PyObject* value = NULL;
608   
609    char* inPath = NULL;
610    char* inId = NULL;
611
612    inPath = null_terminate(path,path_len);
613    inId = null_terminate(id,id_len);
614
615    if (rapptureStarted) {
616        if ((handle) && (*handle != 0)) {
617            lib = getObject_Lib(*handle);
618            value = getObject_Lib(*valHandle);
619           
620            if (lib && value) {
621                // retObj is a borrowed object
622                // whose contents must not be modified
623                rpPutObj(lib, inPath, value, inId, *append);
624            }
625        }
626    }
627
628    if (inPath) {
629        free(inPath);
630        inPath = NULL;
631    }
632
633    if (inId) {
634        free(inId);
635        inId = NULL;
636    }
637
638}
639*/
640
641/*
642int rp_lib_remove (int* handle, char* path, int path_len)
643{
644    int newObjHandle = -1;
645
646    PyObject* lib = NULL;
647    PyObject* removedObj = NULL;
648
649    char* inPath = NULL;
650
651    inPath = null_terminate(path,path_len);
652
653    if (rapptureStarted) {
654        if ((handle) && (*handle != 0)) {
655            lib = getObject_Lib(*handle);
656
657            if (lib) {
658                removedObj = rpRemove(lib, inPath);
659
660                if (removedObj) {
661                    newObjHandle = storeObject_Lib(removedObj);
662                    // Py_DECREF(removedObj);
663                }
664
665            }
666        }
667    }
668
669    if (inPath) {
670        free(inPath);
671        inPath = NULL;
672    }
673
674    return newObjHandle;
675}
676*/
677
678/*
679int rp_lib_xml_len (int* handle)
680{
681    int length = -1;
682    char* xmlText = NULL;
683
684    PyObject* lib = NULL;
685
686    if (rapptureStarted) {
687        if ((handle) && (*handle != 0)) {
688            lib = getObject_Lib(*handle);
689
690            if (lib) {
691                // dont modify xmlText, borrowed pointer
692                xmlText = rpXml(lib);
693
694                if (xmlText) {
695                    length = strlen(xmlText) + 1;
696                    free(xmlText);
697                    // printf("len = :%d:\n",length);
698                }
699            }
700        }
701    }
702    return length;
703}
704*/
705
706int rp_lib_write_xml(int* handle, char* outFile, int outFile_len)
707{
708    int retVal = -1;
709    RpLibrary* lib = NULL;
710    std::string inOutFile = "";
711    std::string xmlText = "";
712    std::fstream file;
713
714    inOutFile = null_terminate_str(outFile, outFile_len);
715
716    if (!inOutFile.empty() ) {
717        file.open(inOutFile.c_str(),std::ios::out);
718    }
719
720    if ( file.is_open() ) {
721        if ((handle) && (*handle != 0)) {
722            lib = getObject_Lib(*handle);
723
724            if (lib) {
725                xmlText = lib->xml();
726                if (!xmlText.empty()) {
727                    file << xmlText;
728                    retVal = 0;
729                }
730            }
731        }
732
733        file.close();
734    }
735
736    return retVal;
737}
738
739void  rp_lib_xml(int* handle, char* retText, int retText_len)
740{
741    std::string xmlText = "";
742
743    RpLibrary* lib = NULL;
744
745    if ((handle) && (*handle != 0)) {
746        lib = getObject_Lib(*handle);
747
748        if (lib) {
749            xmlText = lib->xml();
750            if (!xmlText.empty()) {
751                fortranify(xmlText.c_str(), retText, retText_len);
752            }
753        }
754    }
755}
756
757void rp_lib_node_comp ( int* handle, char* retText, int retText_len ) {
758
759    std::string retStr = "";
760    RpLibrary* node = NULL;
761
762    if ((handle) && (*handle != 0)) {
763        node = getObject_Lib(*handle);
764
765        if (node) {
766            retStr = node->nodeComp();
767            if (!retStr.empty()) {
768                fortranify(retStr.c_str(), retText, retText_len);
769            }
770        }
771    }
772}
773
774void rp_lib_node_type ( int* handle, char* retText, int retText_len ) {
775
776    std::string retStr = "";
777    RpLibrary* node = NULL;
778
779    if ((handle) && (*handle != 0)) {
780        node = getObject_Lib(*handle);
781
782        if (node) {
783            retStr = node->nodeType();
784            if (!retStr.empty()) {
785                fortranify(retStr.c_str(), retText, retText_len);
786            }
787        }
788    }
789}
790
791void rp_lib_node_id ( int* handle, char* retText, int retText_len ) {
792
793    std::string retStr = "";
794    RpLibrary* node = NULL;
795
796    if ((handle) && (*handle != 0)) {
797        node = getObject_Lib(*handle);
798
799        if (node) {
800            retStr = node->nodeId();
801            if (!retStr.empty()) {
802                fortranify(retStr.c_str(), retText, retText_len);
803            }
804        }
805    }
806}
807
808void rp_quit()
809{
810
811    // clean up the dictionary
812
813    RpDictEntry DICT_TEMPLATE *hPtr;
814    // RpDictIterator DICT_TEMPLATE iter((RpDict&)*this);
815    RpDictIterator DICT_TEMPLATE iter(fortObjDict_Lib);
816
817    hPtr = iter.first();
818
819    while (hPtr) {
820        // Py_DECREF(*(hPtr->getValue()));
821        hPtr->erase();
822        hPtr = iter.next();
823    }
824
825    if (fortObjDict_Lib.size()) {
826        // probably want to change the warning sometime
827        // printf("\nWARNING: internal dictionary is not empty..deleting\n");
828    }
829
830}
831
832void rp_result(int* handle) {
833    RpLibrary* lib = NULL;
834
835    if (handle && *handle != 0) {
836        lib = getObject_Lib(*handle);
837        if (lib) {
838            lib->result();
839        }
840    }
841}
842
843int objType( char* flavor)
844{
845    if (flavor == NULL) {
846        // return a PyObject*
847        return 0;
848    }
849    else if((*flavor == 'o')&&(strncmp(flavor,"object", 6)==0)){
850        // return a PyObject*
851        return 0;
852    }
853    else if (
854      ((*flavor == 't')&&(strncmp(flavor,"type", 4) == 0))
855    ||((*flavor == 'i')&&(strncmp(flavor,"id", 2) == 0))
856    ||((*flavor == 'c')&&(strncmp(flavor,"component", 9) == 0)))
857    {
858        // return a char*
859        // convert the result to c style strings
860        return 1;
861    }
862    else {
863        // unrecognized format
864        return -1;
865    }
866}
867
868int storeObject_Lib(RpLibrary* objectName) {
869
870    int retVal = -1;
871    int dictKey = fortObjDict_Lib.size() + 1;
872    int newEntry = 0;
873
874    if (objectName) {
875        // dictionary returns a reference to the inserted value
876        // no error checking to make sure it was successful in entering
877        // the new entry.
878        fortObjDict_Lib.set(dictKey,objectName, &newEntry);
879    }
880
881    retVal = dictKey;
882    return retVal;
883}
884
885RpLibrary* getObject_Lib(int objKey) {
886
887    RpLibrary* retVal = *(fortObjDict_Lib.find(objKey).getValue());
888
889    if (retVal == *(fortObjDict_Lib.getNullEntry().getValue())) {
890        retVal = NULL;
891    }
892
893   return retVal;
894
895}
Note: See TracBrowser for help on using the repository browser.