source: trunk/src/fortran/rappture_fortran.c @ 49

Last change on this file since 49 was 49, checked in by dkearney, 16 years ago

changed all functions with PyString_AsString calls to copy the contents
of the returned python object to newly allocated memory and return the
newly allocated memory. this leaves it up to the user to free all of
the returned items, while the interface function is still responsible
for taking care of python's memory.

File size: 38.6 KB
Line 
1#include "rappture_interface.h"
2#include "RpDict.h"
3#include <string.h>
4
5/*
6// rappture-fortran api
7*/
8
9#ifdef COMPNAME_ADD1UNDERSCORE
10#   define rp_init                 rp_init_
11#   define rp_lib                  rp_lib_
12#   define rp_lib_element_comp     rp_lib_element_comp_
13#   define rp_lib_element_id       rp_lib_element_id_
14#   define rp_lib_element_type     rp_lib_element_type_
15#   define rp_lib_element_str      rp_lib_element_str_
16#   define rp_lib_element_obj      rp_lib_element_obj_
17#   define rp_lib_child_num        rp_lib_child_num_
18#   define rp_lib_child_comp       rp_lib_child_comp_
19#   define rp_lib_child_id         rp_lib_child_id_
20#   define rp_lib_child_type       rp_lib_child_type_
21#   define rp_lib_child_str        rp_lib_child_str_
22#   define rp_lib_child_obj        rp_lib_child_obj_
23#   define rp_lib_get              rp_lib_get_
24#   define rp_lib_get_double       rp_lib_get_double_
25#   define rp_lib_put_str          rp_lib_put_str_
26#   define rp_lib_put_id_str       rp_lib_put_id_str_
27#   define rp_lib_put_obj          rp_lib_put_obj_
28#   define rp_lib_put_id_obj       rp_lib_put_id_obj_
29#   define rp_lib_remove           rp_lib_remove_
30#   define rp_lib_xml_len          rp_lib_xml_len_
31#   define rp_lib_write_xml        rp_lib_write_xml_
32#   define rp_lib_xml              rp_lib_xml_
33#   define rp_quit                 rp_quit_
34#elif defined(COMPNAME_ADD2UNDERSCORE)
35#   define rp_init                 rp_init__
36#   define rp_lib                  rp_lib__
37#   define rp_lib_element_comp     rp_lib_element_comp__
38#   define rp_lib_element_id       rp_lib_element_id__
39#   define rp_lib_element_type     rp_lib_element_type__
40#   define rp_lib_element_str      rp_lib_element_str__
41#   define rp_lib_element_obj      rp_lib_element_obj__
42#   define rp_lib_child_num        rp_lib_child_num__
43#   define rp_lib_child_comp       rp_lib_child_comp__
44#   define rp_lib_child_id         rp_lib_child_id__
45#   define rp_lib_child_type       rp_lib_child_type__
46#   define rp_lib_child_str        rp_lib_child_str__
47#   define rp_lib_child_obj        rp_lib_child_obj__
48#   define rp_lib_get              rp_lib_get__
49#   define rp_lib_get_double       rp_lib_get_double__
50#   define rp_lib_put_str          rp_lib_put_str__
51#   define rp_lib_put_id_str       rp_lib_put_id_str__
52#   define rp_lib_put_obj          rp_lib_put_obj__
53#   define rp_lib_put_id_obj       rp_lib_put_id_obj__
54#   define rp_lib_remove           rp_lib_remove__
55#   define rp_lib_xml_len          rp_lib_xml_len__
56#   define rp_lib_write_xml        rp_lib_write_xml__
57#   define rp_lib_xml              rp_lib_xml__
58#   define rp_quit                 rp_quit__
59#elif defined(COMPNAME_NOCHANGE)
60#   define rp_init                 rp_init
61#   define rp_lib                  rp_lib
62#   define rp_lib_element_comp     rp_lib_element_comp
63#   define rp_lib_element_id       rp_lib_element_id
64#   define rp_lib_element_type     rp_lib_element_type
65#   define rp_lib_element_str      rp_lib_element_str
66#   define rp_lib_element_obj      rp_lib_element_obj
67#   define rp_lib_child_num        rp_lib_child_num
68#   define rp_lib_child_comp       rp_lib_child_comp
69#   define rp_lib_child_id         rp_lib_child_id
70#   define rp_lib_child_type       rp_lib_child_type
71#   define rp_lib_child_str        rp_lib_child_str
72#   define rp_lib_child_obj        rp_lib_child_obj
73#   define rp_lib_get              rp_lib_get
74#   define rp_lib_get_double       rp_lib_get_double
75#   define rp_lib_put_str          rp_lib_put_str
76#   define rp_lib_put_id_str       rp_lib_put_id_str
77#   define rp_lib_put_obj          rp_lib_put_obj
78#   define rp_lib_put_id_obj       rp_lib_put_id_obj
79#   define rp_lib_remove           rp_lib_remove
80#   define rp_lib_xml_len          rp_lib_xml_len
81#   define rp_lib_write_xml        rp_lib_write_xml
82#   define rp_lib_xml              rp_lib_xml
83#   define rp_quit                 rp_quit
84#elif defined(COMPNAME_UPPERCASE)
85#   define rp_init                 RP_INIT
86#   define rp_lib                  RP_LIB
87#   define rp_lib_element_comp     RP_LIB_ELEMENT_COMP
88#   define rp_lib_element_id       RP_LIB_ELEMENT_ID
89#   define rp_lib_element_type     RP_LIB_ELEMENT_TYPE
90#   define rp_lib_element_str      RP_LIB_ELEMENT_STR
91#   define rp_lib_element_obj      RP_LIB_ELEMENT_OBJ
92#   define rp_lib_child_num        RP_LIB_CHILD_NUM
93#   define rp_lib_child_comp       RP_LIB_CHILD_COMP
94#   define rp_lib_child_id         RP_LIB_CHILD_ID
95#   define rp_lib_child_type       RP_LIB_CHILD_TYPE
96#   define rp_lib_child_str        RP_LIB_CHILD_STR
97#   define rp_lib_child_obj        RP_LIB_CHILD_OBJ
98#   define rp_lib_get              RP_LIB_GET
99#   define rp_lib_get_double       RP_LIB_GET_DOUBLE
100#   define rp_lib_put_str          RP_LIB_PUT_STR
101#   define rp_lib_put_id_str       RP_LIB_PUT_ID_STR
102#   define rp_lib_put_obj          RP_LIB_PUT_OBJ
103#   define rp_lib_put_id_obj       RP_LIB_PUT_ID_OBJ
104#   define rp_lib_remove           RP_LIB_REMOVE
105#   define rp_lib_xml_len          RP_LIB_XML_LEN
106#   define rp_lib_write_xml        RP_LIB_WRITE_XML
107#   define rp_lib_xml              RP_LIB_XML
108#   define rp_quit                 RP_QUIT
109#endif
110
111
112extern "C"
113void rp_init();
114
115extern "C"
116int rp_lib(const char* filePath, int filePath_len);
117
118extern "C"
119void rp_lib_element_comp( int* handle,
120                            char* path,
121                            char* retText,
122                            int path_len,
123                            int retText_len );
124
125extern "C"
126void rp_lib_element_id(   int* handle,
127                            char* path,
128                            char* retText,
129                            int path_len,
130                            int retText_len );
131
132extern "C"
133void rp_lib_element_type( int* handle,
134                            char* path,
135                            char* retText,
136                            int path_len,
137                            int retText_len );
138
139extern "C"
140void rp_lib_element_str(  int* handle,
141                            char* path,
142                            char* flavor,
143                            char* retText,
144                            int path_len,
145                            int flavor_len,
146                            int retText_len );
147
148extern "C"
149int rp_lib_element_obj(   int* handle,
150                            char* path,
151                            int path_len );
152
153extern "C"
154int rp_lib_child_num(    int* handle,
155                            char* path,
156                            int path_len);
157
158extern "C"
159int rp_lib_child_comp(   int* handle,    /* integer handle of library */
160                            char* path,     /* DOM path of requested object */
161                            char* type,     /* specific name of element */
162                            int* childNum,  /* child number for iteration */
163                            char* retText,  /* buffer to store return text */
164                            int path_len,   /* length of path */
165                            int type_len,   /* length of type */
166                            int retText_len /* length of return text buffer */
167                       );
168
169extern "C"
170int rp_lib_child_id(     int* handle,    /* integer handle of library */
171                            char* path,     /* DOM path of requested object */
172                            char* type,     /* specific name of element */
173                            int* childNum,  /* child number for iteration */
174                            char* retText,  /* buffer to store return text */
175                            int path_len,   /* length of path */
176                            int type_len,   /* length of type */
177                            int retText_len /* length of return text buffer */
178                       );
179
180extern "C"
181int rp_lib_child_type(   int* handle,    /* integer handle of library */
182                            char* path,     /* DOM path of requested object */
183                            char* type,     /* specific name of element */
184                            int* childNum,  /* child number for iteration */
185                            char* retText,  /* buffer to store return text */
186                            int path_len,   /* length of path */
187                            int type_len,   /* length of type */
188                            int retText_len /* length of return text buffer */
189                       );
190
191extern "C"
192int rp_lib_child_str(    int* handle,    /* integer handle of library */
193                            char* path,     /* DOM path of requested object */
194                            char* flavor,   /* information you want returned*/
195                            char* type,     /* specific name of element */
196                            int* childNum,  /* child number for iteration */
197                            char* retText,  /* buffer to store return text */
198                            int path_len,   /* length of path */
199                            int flavor_len, /* length of flavor */
200                            int type_len,   /* length of type */
201                            int retText_len /* length of return text buffer */
202                       );
203
204extern "C"
205int rp_lib_child_obj(    int* handle,
206                            char* path,
207                            char* type,
208                            int path_len,
209                            int type_len
210                          );
211
212extern "C"
213void rp_lib_get(          int* handle,
214                            char* path,
215                            char* retText,
216                            int path_len,
217                            int retText_len );
218
219extern "C"
220double rp_lib_get_double( int* handle,
221                            char* path,
222                            int path_len);
223
224extern "C"
225void rp_lib_put_str(     int* handle,
226                            char* path,
227                            char* value,
228                            int* append,
229                            int path_len,
230                            int value_len );
231
232extern "C"
233void rp_lib_put_id_str(  int* handle,
234                            char* path,
235                            char* value,
236                            char* id,
237                            int* append,
238                            int path_len,
239                            int value_len,
240                            int id_len );
241
242extern "C"
243void rp_lib_put_obj(     int* handle,
244                            char* path,
245                            int* valHandle,
246                            int* append,
247                            int path_len );
248
249extern "C"
250void rp_lib_put_id_obj(  int* handle,
251                            char* path,
252                            int* valHandle,
253                            char* id,
254                            int* append,
255                            int path_len,
256                            int id_len );
257
258extern "C"
259int rp_lib_remove(       int* handle,
260                            char* path,
261                            int path_len);
262
263extern "C"
264int rp_lib_xml_len(      int* handle);
265
266extern "C"
267void rp_lib_xml(         int* handle,
268                            char* retText,
269                            int retText_len);
270
271extern "C"
272int rp_lib_write_xml(     int* handle,
273                            char* outFile,
274                            int outFile_len);
275extern "C"
276void rp_quit();
277
278
279/**********************************************************/
280
281/**********************************************************/
282
283// private member functions
284int storeNode(PyObject* node);
285int objType( char* flavor);
286
287int storeObject(PyObject* objectName);
288PyObject* getObject(int objKey);
289char* null_terminate(char* inStr, int len);
290
291// global vars
292// dictionary to hold the python objects that
293// cannot be sent to fortran
294
295#define DICT_TEMPLATE <int,PyObject*>
296RpDict DICT_TEMPLATE fortObjDict;
297int rapptureStarted = 0;
298
299void rp_init() {
300    //
301    PyObject* rpClass = NULL;
302    int retVal = 0;
303   
304    // initialize the interpreter
305    Py_Initialize();
306    rpClass = importRappture();
307
308    if (rpClass) {
309        // store the handle in the dictionary
310        retVal = storeObject(rpClass);
311        rapptureStarted = 1;
312    }
313}
314
315int rp_lib(const char* filePath, int filePath_len)
316{
317    PyObject* lib = NULL;
318    PyObject* rpClass = NULL;
319    int handle = -1;
320    char* inFilePath = NULL;
321
322    if (!rapptureStarted) {
323        rp_init();
324    }
325
326    inFilePath = null_terminate((char*)filePath, filePath_len);
327   
328    // error checking to make sure inText is valid???
329   
330    // grab the rappture class from the dictionary
331    rpClass = getObject(0);
332
333    if (rpClass) {
334
335
336        // create a RapptureIO object and store in dictionary
337        lib = createRapptureObj(rpClass, inFilePath);
338
339        if (lib) {
340            handle = storeObject(lib);
341        }
342    }
343
344    if (inFilePath) {
345        free(inFilePath);
346        inFilePath = NULL;
347    }
348
349    return handle;
350}
351
352int rp_lib_element_obj(int* handle,     /* integer handle of library */
353                          char* path,     /* null terminated path */
354                          int path_len
355                        )
356{
357    int newObjHandle = -1;
358
359    const char* flavor = "object";
360    char* inPath = NULL;
361
362    PyObject* lib = NULL;
363    PyObject* retObj = NULL;
364
365    inPath = null_terminate(path,path_len);
366
367    // error checking to make sure inText is valid???
368
369    if (fortObjDict.size() > 0) {
370        if ((handle) && (*handle != 0)) {
371            lib = getObject(*handle);
372            if (lib) {
373                retObj = (PyObject*) rpElement(lib, inPath, flavor);
374               
375                if (retObj) {
376
377                    newObjHandle = storeObject(retObj);
378                    // Py_DECREF(retObj);
379                }
380            }
381        }
382    }
383
384    if (inPath) {
385        free(inPath);
386        inPath = NULL;
387    }
388
389    return newObjHandle;
390}
391
392void rp_lib_element_comp( int* handle, /* integer handle of library */
393                            char* path,      /* null terminated path */
394                            char* retText,   /* return buffer for fortran*/
395                            int path_len,
396                            int retText_len /* length of return text buffer */
397                          )
398{
399    char* inPath = NULL;
400
401    inPath = null_terminate(path,path_len);
402    if (path_len) {
403        path_len = strlen(inPath) + 1;
404    }
405    else {
406        path_len = 0;
407    }
408
409    // error checking to make sure inText is valid???
410
411    rp_lib_element_str(handle,inPath,"component",retText,path_len,10,retText_len);
412   
413    if (inPath) {
414        free(inPath);
415        inPath = NULL;
416    }
417
418}
419
420void rp_lib_element_id(   int* handle, /* integer handle of library */
421                            char* path,      /* null terminated path */
422                            char* retText,   /* return buffer for fortran*/
423                            int path_len,
424                            int retText_len /* length of return text buffer */
425                        )
426{
427    char* inPath = NULL;
428    inPath = null_terminate(path,path_len);
429    if (inPath) {
430        path_len = strlen(inPath) + 1;
431    }
432    else {
433        path_len = 0;
434    }
435
436    rp_lib_element_str(handle,inPath,"id",retText,path_len,3,retText_len);
437    if (inPath) {
438        free(inPath);
439        inPath = NULL;
440    }
441
442
443}
444
445void rp_lib_element_type( int* handle, /* integer handle of library */
446                            char* path,      /* null terminated path */
447                            char* retText,   /* return buffer for fortran*/
448                            int path_len,
449                            int retText_len /* length of return text buffer */
450                          )
451{
452    char* inPath = NULL;
453    inPath = null_terminate(path,path_len);
454    if (inPath) {
455        path_len = strlen(inPath) + 1;
456    }
457    else {
458        path_len = 0;
459    }
460    rp_lib_element_str(handle,path,"type",retText,path_len,5,retText_len);
461    if (inPath) {
462        free(inPath);
463        inPath = NULL;
464    }
465
466
467}
468
469void rp_lib_element_str(  int* handle, /* integer handle of library */
470                            char* path,      /* null terminated path */
471                            char* flavor,    /* null terminated flavor */
472                            char* retText,   /* return buffer for fortran*/
473                            int path_len,
474                            int flavor_len,
475                            int retText_len /* length of return text buffer */
476                        )
477{
478    int length_in = 0;
479    int length_out = 0;
480    int i = 0;
481    const char* xmlText = NULL;
482
483    PyObject* lib = NULL;
484   
485    char* retObj = NULL;
486   
487    char* inPath = NULL;
488    char* inFlavor = NULL;
489
490    inPath = null_terminate(path,path_len);
491    inFlavor = null_terminate(flavor,flavor_len);
492
493    if (rapptureStarted) {
494        if ((handle) && (*handle != 0)) {
495            lib = getObject(*handle);
496
497            if (lib) {
498                if(objType(inFlavor) == 1) {
499
500                    retObj = (char*) rpElement(lib, inPath, inFlavor);
501                    if (retObj) {
502                        xmlText = retObj;
503                   
504                        length_in = strlen(xmlText);
505                        length_out = retText_len;
506
507                        strncpy(retText, xmlText, length_out);
508
509                        // fortran-ify the string
510                        if (length_in < length_out) {
511                              for (i = length_in; i < length_out; i++) {
512                                  retText[i] = ' ';
513                              }
514                        }
515                        *(retText+length_out-1) = ' ';
516                       
517                        free(retObj);
518                        retObj = NULL;
519                    }
520                    else {
521                       
522                    }
523                }
524
525            }
526        }
527    }
528   
529    if (inPath) {
530        free(inPath);
531        inPath = NULL;
532    }
533
534    if (inFlavor) {
535        free(inFlavor);
536        inFlavor = NULL;
537    }
538
539}
540
541int rp_lib_child_num( int* handle,
542                         char* path,
543                         int path_len
544                       )
545{
546    int numChildren = 0;
547
548    PyObject* lib = NULL;
549    PyObject* list = NULL;
550    char* inPath = NULL;
551
552    inPath = null_terminate(path,path_len);
553   
554    if (rapptureStarted) {
555        if ((handle) && (*handle != 0)) {
556            lib = getObject(*handle);
557
558            if (lib) {
559                list = rpChildren_f(lib, inPath, "type");
560                if (list) {
561                    numChildren = PyList_Size(list);
562                    Py_DECREF(list);
563                }
564                else {
565                   
566                }
567            }
568        }
569    }
570
571    if (inPath) {
572        free(inPath);
573        inPath = NULL;
574    }
575
576    return numChildren;
577
578}
579
580
581int rp_lib_child_comp (   int* handle,    /* integer handle of library */
582                            char* path,     /* DOM path of requested object */
583                            char* type,     /* specific name of element */
584                            int* childNum,  /* child number for iteration */
585                            char* retText,  /* buffer to store return text */
586                            int path_len,   /* length of path */
587                            int type_len,   /* length of type */
588                            int retText_len /* length of return text buffer */
589                       )
590{
591    int retVal = 0;
592
593    char* inPath = NULL;
594    char* inType = NULL;
595
596    inPath = null_terminate(path,path_len);
597    inType = null_terminate(type,type_len);
598
599    if (inPath) {
600        path_len = strlen(inPath) + 1;
601    }
602    else {
603        path_len = 0;
604    }
605
606    if (inType) {
607        type_len = strlen(inType) + 1;
608    }
609    else {
610        type_len = 0;
611    }
612
613    retVal = rp_lib_child_str( handle,
614                                 inPath,
615                                 "component",
616                                 inType,
617                                 childNum,
618                                 retText,
619                                 path_len,
620                                 10,
621                                 type_len,
622                                 retText_len
623                               );
624
625    if (inPath) {
626        free(inPath);
627        inPath = NULL;
628    }
629
630    if (inType) {
631        free(inType);
632        inType = NULL;
633    }
634
635    return retVal;
636}
637
638int rp_lib_child_id(   int* handle,    /* integer handle of library */
639                          char* path,     /* DOM path of requested object */
640                          char* type,     /* specific name of element */
641                          int* childNum,  /* child number for iteration */
642                          char* retText,  /* buffer to store return text */
643                          int path_len,   /* length of path */
644                          int type_len,   /* length of type */
645                          int retText_len /* length of return text buffer */
646                       )
647{
648    int retVal = 0;
649    char* inPath = NULL;
650    char* inType = NULL;
651
652    inPath = null_terminate(path,path_len);
653    inType = null_terminate(type,type_len);
654
655    if (inPath) {
656        path_len = strlen(inPath) + 1;
657    }
658    else {
659        path_len = 0;
660    }
661
662    if (inType) {
663        type_len = strlen(inType) + 1;
664    }
665    else {
666        type_len = 0;
667    }
668
669    retVal = rp_lib_child_str( handle,
670                                 inPath,
671                                 "id",
672                                 inType,
673                                 childNum,
674                                 retText,
675                                 path_len,
676                                 3,
677                                 type_len,
678                                 retText_len
679                               );
680
681    if (inPath) {
682        free(inPath);
683        inPath = NULL;
684    }
685
686    if (inType) {
687        free(inType);
688        inType = NULL;
689    }
690
691    return retVal;
692}
693
694int rp_lib_child_type (   int* handle,    /* integer handle of library */
695                            char* path,     /* DOM path of requested object */
696                            char* type,     /* specific name of element */
697                            int* childNum,  /* child number for iteration */
698                            char* retText,  /* buffer to store return text */
699                            int path_len,   /* length of path */
700                            int type_len,   /* length of type */
701                            int retText_len /* length of return text buffer */
702                       )
703{
704    int retVal = 0;
705    char* inPath = NULL;
706    char* inType = NULL;
707
708    inPath = null_terminate(path,path_len);
709    inType = null_terminate(type,type_len);
710
711    if (inPath) {
712        path_len = strlen(inPath) + 1;
713    }
714    else {
715        path_len = 0;
716    }
717
718    if (inType) {
719        type_len = strlen(inType) + 1;
720    }
721    else {
722        type_len = 0;
723    }
724
725    retVal = rp_lib_child_str( handle,
726                                 inPath,
727                                 "type",
728                                 inType,
729                                 childNum,
730                                 retText,
731                                 path_len,
732                                 5,
733                                 type_len,
734                                 retText_len
735                               );
736
737    if (inPath) {
738        free(inPath);
739        inPath = NULL;
740    }
741
742    if (inType) {
743        free(inType);
744        inType = NULL;
745    }
746
747    return retVal;
748}
749
750int rp_lib_child_str (    int* handle,    /* integer handle of library */
751                            char* path,     /* DOM path of requested object */
752                            char* flavor,   /* information you want returned*/
753                            char* type,     /* specific name of element */
754                            int* childNum,  /* child number for iteration */
755                            char* retText,  /* buffer to store return text */
756                            int path_len,   /* length of path */
757                            int flavor_len, /* length of flavor */
758                            int type_len,   /* length of type */
759                            int retText_len /* length of return text buffer */
760                       )
761{
762    int retVal = 0;
763    int i = 0;
764    int length_in = 0;
765
766    PyObject* lib = NULL;
767    PyObject* list = NULL;
768    PyObject* list_item = NULL;
769   
770    char* xmlChild = NULL;
771    char* inPath = NULL;
772    char* inType = NULL;
773    char* inFlavor = NULL;
774   
775    inPath = null_terminate(path,path_len);
776    inFlavor = null_terminate(flavor,flavor_len);
777    inType = null_terminate(type,type_len);
778
779    if (rapptureStarted) {
780        if ((handle) && (*handle != 0)) {
781            lib = getObject(*handle);
782            if (lib) {
783                if(objType(inFlavor) == 1) {
784
785                    list = rpChildren_f(lib, inPath, inFlavor);
786                    if (list) {
787                        retVal = PyList_Size(list);
788                        // check to make sure our node index is within bounds
789                        if (((*childNum)-1) < retVal) {
790                            // get the requested node
791                            list_item = PyList_GetItem(list,(*childNum)-1);
792                            // make node string, borrowed object
793                            xmlChild = PyString_AsString(list_item);
794                            Py_DECREF(list);
795                            // printf("xmlChild = :%s:\n",xmlChild);
796                            if (xmlChild) {
797                                strncpy(retText, xmlChild, retText_len);
798                                length_in = strlen(xmlChild);
799
800                                // fortran-ify the string
801                                if (length_in < retText_len) {
802                                      for (i = length_in; i < retText_len; i++) {
803                                          retText[i] = ' ';
804                                      }
805                                }
806                                // *(retText+retText_len-1) = ' ';
807                            }
808                        }
809                    }
810                    else {
811                       
812                    }
813                }
814            }
815        }
816    }
817
818    if (inPath) {
819        free(inPath);
820        inPath = NULL;
821    }
822
823    if (inFlavor) {
824        free(inFlavor);
825        inFlavor = NULL;
826    }
827
828    if (inType) {
829        free(inType);
830        inType = NULL;
831    }
832
833
834    return retVal;
835}
836
837 int rp_lib_child_obj ( int* handle,
838                            char* path,
839                            char* type,
840                            int path_len,
841                            int type_len
842                          )
843{
844    int newObjHandle = -1;
845
846    PyObject* lib = NULL;
847    PyObject* list = NULL;
848   
849    char* inPath = NULL;
850    char* inType = NULL;
851
852    inPath = null_terminate(path,path_len);
853    inType = null_terminate(type,type_len);
854
855    if (rapptureStarted) {
856        if ((handle) && (*handle != 0)) {
857            lib = getObject(*handle);
858           
859            if (lib) {
860                list = rpChildren_f(lib, inPath, "object");
861                if (list) {
862                    // store the whole list,
863                    // need to make a way to read the nodes
864                    newObjHandle = storeObject(list);
865                    // Py_DECREF(list);
866                }
867                else {
868                   
869                }
870            }
871        }
872    }
873
874    if (inPath) {
875        free(inPath);
876        inPath = NULL;
877    }
878
879    if (inType) {
880        free(inType);
881        inType = NULL;
882    }
883
884    return newObjHandle;
885
886}
887
888
889void rp_lib_get( int* handle, /* integer handle of library */
890                   char* path,      /* null terminated path */
891                   char* retText,   /* return text buffer for fortran*/
892                   int path_len,
893                   int retText_len /* length of return text buffer */
894                 )
895{
896    int length_in = 0;
897    int length_out = 0;
898    int i = 0;
899    const char* xmlText = NULL;
900
901    PyObject* lib = NULL;
902   
903    char* inPath = NULL;
904
905    inPath = null_terminate(path,path_len);
906
907    if (rapptureStarted) {
908        if ((handle) && (*handle != 0)) {
909            lib = getObject(*handle);
910           
911            if (lib) {
912                // retObj is a borrowed object
913                // whose contents must not be modified
914                xmlText = rpGet(lib, inPath);
915               
916                if (xmlText) {
917
918                    length_in = strlen(xmlText);
919                    length_out = retText_len;
920
921                    strncpy(retText, xmlText, length_out);
922
923                    // fortran-ify the string
924                    if (length_in < length_out) {
925                          for (i = length_in; i < length_out; i++) {
926                              retText[i] = ' ';
927                          }
928                    }
929                    *(retText+length_out-1) = ' ';
930                }
931
932            }
933        }
934    }
935
936    if (inPath) {
937        free(inPath);
938        inPath = NULL;
939    }
940
941}
942
943double rp_lib_get_double( int* handle,   /* integer handle of library */
944                            char* path,    /* null terminated path */
945                            int path_len
946                          )
947{
948    double retVal = 0.0;
949    const char* xmlText = NULL;
950
951    PyObject* lib = NULL;
952   
953    char* inPath = NULL;
954
955    inPath = null_terminate(path,path_len);
956
957    path_len = strlen(inPath) + 1;
958
959    if (rapptureStarted) {
960        if ((handle) && (*handle != 0)) {
961            lib = getObject(*handle);
962           
963            if (lib) {
964                // retObj is a borrowed object
965                // whose contents must not be modified
966                xmlText = rpGet(lib, inPath);
967               
968                if (xmlText) {
969                    retVal = atof(xmlText);
970                }
971
972            }
973        }
974    }
975
976    if (inPath) {
977        free(inPath);
978        inPath = NULL;
979    }
980
981    return retVal;
982}
983
984
985void rp_lib_put_str( int* handle,
986                        char* path,
987                        char* value,
988                        int* append,
989                        int path_len,
990                        int value_len
991                      )
992{
993    char* inPath = NULL;
994    char* inValue = NULL;
995
996    inPath = null_terminate(path,path_len);
997    inValue = null_terminate(value,value_len);
998
999
1000    if (inPath) {
1001        path_len = strlen(inPath) + 1;
1002    }
1003    else {
1004        path_len = 0;
1005    }
1006
1007    if (inValue){
1008        value_len = strlen(inValue) + 1;
1009    }
1010    else {
1011        value_len = 0;
1012    }
1013
1014    rp_lib_put_id_str(handle,inPath,inValue,NULL,append,path_len,value_len,0);
1015
1016    if (inPath) {
1017        free(inPath);
1018        inPath = NULL;
1019    }
1020
1021    if (inValue) {
1022        free(inValue);
1023        inValue = NULL;
1024    }
1025}
1026
1027
1028void rp_lib_put_id_str ( int* handle,
1029                        char* path,
1030                        char* value,
1031                        char* id,
1032                        int* append,
1033                        int path_len,
1034                        int value_len,
1035                        int id_len
1036                      )
1037{
1038    PyObject* lib = NULL;
1039   
1040    char* inPath = NULL;
1041    char* inValue = NULL;
1042    char* inId = NULL;
1043
1044    inPath = null_terminate(path,path_len);
1045    inValue = null_terminate(value,value_len);
1046    inId = null_terminate(id,id_len);
1047
1048    if (rapptureStarted) {
1049        if ((handle) && (*handle != 0)) {
1050            lib = getObject(*handle);
1051           
1052            if (lib) {
1053                rpPut(lib, inPath, inValue, inId, *append);
1054            }
1055        }
1056    }
1057
1058    if (inPath) {
1059        free(inPath);
1060        inPath = NULL;
1061    }
1062
1063    if (inValue) {
1064        free(inValue);
1065        inValue = NULL;
1066    }
1067
1068    if (inId) {
1069        free(inId);
1070        inId = NULL;
1071    }
1072
1073}
1074
1075void rp_lib_put_obj( int* handle,
1076                        char* path,
1077                        int* valHandle,
1078                        int* append,
1079                        int path_len
1080                      )
1081{
1082    char* inPath = NULL;
1083
1084    inPath = null_terminate(path,path_len);
1085
1086    if (inPath) {
1087        path_len = strlen(inPath) + 1;
1088    }
1089
1090    rp_lib_put_id_obj(handle,inPath,valHandle,NULL,append,path_len,0);
1091
1092    if (inPath) {
1093        free(inPath);
1094        inPath = NULL;
1095    }
1096
1097}
1098
1099void rp_lib_put_id_obj ( int* handle,
1100                        char* path,
1101                        int* valHandle,
1102                        char* id,
1103                        int* append,
1104                        int path_len,
1105                        int id_len
1106                      )
1107{
1108    PyObject* lib = NULL;
1109    PyObject* value = NULL;
1110   
1111    char* inPath = NULL;
1112    char* inId = NULL;
1113
1114    inPath = null_terminate(path,path_len);
1115    inId = null_terminate(id,id_len);
1116
1117    if (rapptureStarted) {
1118        if ((handle) && (*handle != 0)) {
1119            lib = getObject(*handle);
1120            value = getObject(*valHandle);
1121           
1122            if (lib && value) {
1123                // retObj is a borrowed object
1124                // whose contents must not be modified
1125                rpPutObj(lib, inPath, value, inId, *append);
1126            }
1127        }
1128    }
1129
1130    if (inPath) {
1131        free(inPath);
1132        inPath = NULL;
1133    }
1134
1135    if (inId) {
1136        free(inId);
1137        inId = NULL;
1138    }
1139
1140}
1141
1142int rp_lib_remove (int* handle, char* path, int path_len)
1143{
1144    int newObjHandle = -1;
1145
1146    PyObject* lib = NULL;
1147    PyObject* removedObj = NULL;
1148   
1149    char* inPath = NULL;
1150
1151    inPath = null_terminate(path,path_len);
1152
1153    if (rapptureStarted) {
1154        if ((handle) && (*handle != 0)) {
1155            lib = getObject(*handle);
1156
1157            if (lib) {
1158                removedObj = rpRemove(lib, inPath);
1159               
1160                if (removedObj) {
1161                    newObjHandle = storeObject(removedObj);
1162                    // Py_DECREF(removedObj);
1163                }
1164
1165            }
1166        }
1167    }
1168   
1169    if (inPath) {
1170        free(inPath);
1171        inPath = NULL;
1172    }
1173
1174    return newObjHandle;
1175}
1176
1177int rp_lib_xml_len (int* handle)
1178{
1179    int length = -1;
1180    char* xmlText = NULL;
1181
1182    PyObject* lib = NULL;
1183
1184    if (rapptureStarted) {
1185        if ((handle) && (*handle != 0)) {
1186            lib = getObject(*handle);
1187
1188            if (lib) {
1189                // dont modify xmlText, borrowed pointer
1190                xmlText = rpXml(lib);
1191
1192                if (xmlText) {
1193                    length = strlen(xmlText) + 1;
1194                    free(xmlText);
1195                    // printf("len = :%d:\n",length);
1196                }
1197            }
1198        }
1199    }
1200    return length;
1201}
1202
1203void  rp_lib_xml(int* handle, char* retText, int retText_len)
1204{
1205    int length_in = 0;
1206    int length_out = 0;
1207    int i = 0;
1208    char* xmlText = NULL;
1209
1210    PyObject* lib = NULL;
1211   
1212    if (rapptureStarted) {
1213        if ((handle) && (*handle != 0)) {
1214            lib = getObject(*handle);
1215
1216            if (lib) {
1217                xmlText = rpXml(lib);
1218               
1219                if (xmlText) {
1220                    length_in = strlen(xmlText);
1221                    length_out = retText_len;
1222
1223                    strncpy(retText, xmlText, length_out);
1224
1225                    // fortran-ify the string
1226                    if (length_in < length_out) {
1227                          for (i = length_in; i < length_out; i++) {
1228                              retText[i] = ' ';
1229                          }
1230                    }
1231                    *(retText+length_out-1) = ' ';
1232
1233                    free(xmlText);
1234                }
1235               
1236            }
1237        }
1238    }
1239}
1240
1241int rp_lib_write_xml(int* handle, char* outFile, int outFile_len)
1242{
1243    int retVal = -1;
1244    PyObject* lib = NULL;
1245    FILE* outFH = NULL;
1246    char* inOutFile = NULL;
1247    char* xmlText = NULL;
1248
1249    inOutFile = null_terminate(outFile, outFile_len);
1250
1251    if (inOutFile && (inOutFile != "") ) {
1252        outFH = fopen(inOutFile, "w");
1253    }
1254
1255    if (outFH && rapptureStarted) {
1256        if ((handle) && (*handle != 0)) {
1257            lib = getObject(*handle);
1258
1259            if (lib) {
1260                xmlText = rpXml(lib);
1261                if (xmlText) {
1262                    retVal = fputs(xmlText,outFH);
1263                    free(xmlText);
1264                }
1265            }
1266        }
1267    }
1268
1269    if (outFH) {
1270        fclose(outFH);
1271        outFH = NULL;
1272    }
1273
1274    if (inOutFile) {
1275        free(inOutFile);
1276        inOutFile = NULL;
1277    }
1278
1279    return retVal;
1280}
1281
1282void rp_quit()
1283{
1284
1285    // clean up python's memory
1286    // shut down the python interpreter
1287    // clean up the dictionary
1288
1289    RpDictEntry DICT_TEMPLATE *hPtr;
1290    // RpDictIterator DICT_TEMPLATE iter((RpDict&)*this);                     
1291    RpDictIterator DICT_TEMPLATE iter(fortObjDict);
1292   
1293    hPtr = iter.first();                                                     
1294   
1295    while (hPtr) {
1296        Py_DECREF(*(hPtr->getValue()));
1297        hPtr->erase();
1298        hPtr = iter.next();                                                   
1299    }
1300
1301    if (fortObjDict.size()) {
1302        // probably want to change the warning sometime
1303        // printf("\nWARNING: internal dictionary is not empty..deleting\n");
1304    }
1305
1306    rapptureStarted = 0;
1307    // Py_Finalize();
1308}
1309
1310int objType( char* flavor)
1311{
1312    if (flavor == NULL) {
1313        // return a PyObject*
1314        return 0;
1315    }
1316    else if((*flavor == 'o')&&(strncmp(flavor,"object", 6)==0)){
1317        // return a PyObject*
1318        return 0;
1319    }
1320    else if (
1321      ((*flavor == 't')&&(strncmp(flavor,"type", 4) == 0))
1322    ||((*flavor == 'i')&&(strncmp(flavor,"id", 2) == 0))
1323    ||((*flavor == 'c')&&(strncmp(flavor,"component", 9) == 0)))
1324    {
1325        // return a char*
1326        // convert the result to c style strings
1327        return 1;
1328    }
1329    else {
1330        // unrecognized format
1331        return -1;
1332    }
1333}
1334
1335int storeObject(PyObject* objectName) {
1336
1337    int retVal = -1;
1338    int dictKey = fortObjDict.size();
1339    int newEntry = 0;
1340
1341    if (objectName) {
1342        // dictionary returns a reference to the inserted value
1343        // no error checking to make sure it was successful in entering
1344        // the new entry.
1345        fortObjDict.set(dictKey,objectName, &newEntry);
1346    }
1347   
1348    retVal = dictKey;
1349    return retVal;
1350}
1351
1352PyObject* getObject(int objKey) {
1353
1354    PyObject* retVal = *(fortObjDict.find(objKey).getValue());
1355
1356    if (retVal == *(fortObjDict.getNullEntry().getValue())) {
1357        retVal = NULL;
1358    }
1359
1360   return retVal;
1361
1362}
1363
1364/* fix buffer overflow possibility*/
1365char* null_terminate(char* inStr, int len)
1366{
1367    int retVal = 0;
1368    char* newStr = NULL;
1369    char* current = NULL;
1370
1371    if (inStr) {
1372
1373        current = inStr+len-1;
1374
1375        while ((len > 0) && (isspace(*(current)))) {
1376            // dont strip off newlines
1377
1378            if ( (*(current) == '\f')
1379              || (*(current) == '\n')
1380              || (*(current) == '\r')
1381              || (*(current) == '\t')
1382              || (*(current) == '\v') )
1383            {
1384                break;
1385            }
1386
1387            if (--len) {
1388                current--;
1389            }
1390        }
1391
1392        newStr = (char*) calloc(len+1,(sizeof(char)));
1393        strncpy(newStr,inStr,len);
1394        *(newStr+len) = '\0';
1395
1396        retVal++;
1397    }
1398
1399    // return retVal;
1400
1401    return newStr;
1402}
Note: See TracBrowser for help on using the repository browser.