Changeset 76


Ignore:
Timestamp:
Sep 29, 2005 11:45:32 AM (15 years ago)
Author:
dkearney
Message:
  1. cleaned up make files some more, deleted make.inc files
  2. updated RpUnits module and Cee and Fortran interfaces
  3. changed return values for some fortran interfaces,

error messages not working yet

  1. still need to add copy assignment code to RpUnits
Location:
trunk
Files:
6 added
6 deleted
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/include/cee/RpUnitsCInterface.h

    r19 r76  
    3030
    3131    // convert functions
    32     const char* convert_str(    RpUnits* fromUnits,
     32
     33    const char* convert (   const char* fromVal,
     34                            const char* toUnitsName,
     35                            int showUnits,
     36                            int* result );
     37   
     38    const char* convert_str (   const char* fromVal,
     39                                const char* toUnitsName,
     40                                int showUnits,
     41                                int* result );
     42   
     43    const char* convert_obj_str (   RpUnits* fromUnits,
     44                                    RpUnits* toUnits,
     45                                    double val,
     46                                    int showUnits   );
     47   
     48    const char* convert_obj_str_result( RpUnits* fromUnits,
     49                                        RpUnits* toUnits,
     50                                        double val,
     51                                        int showUnits,
     52                                        int* result );
     53
     54    double convert_dbl (    const char* fromVal,
     55                            const char* toUnitsName,
     56                            int* result );
     57   
     58    double convert_obj_double ( RpUnits* fromUnits,
    3359                                RpUnits* toUnits,
    34                                 double val,
    35                                 int showUnits   );
    36    
    37     const char* convert_str_result( RpUnits* fromUnits,
    38                                     RpUnits* toUnits,
    39                                     double val,
    40                                     int showUnits,
    41                                     int* result );
     60                                double val  );
    4261
    43     double convert_double(RpUnits* fromUnits, RpUnits* toUnits, double val);
     62    double convert_obj_double_result (  RpUnits* fromUnits,
     63                                        RpUnits* toUnits,
     64                                        double val,
     65                                        int* result );
    4466
    45     double convert_double_result(   RpUnits* fromUnits,
    46                                     RpUnits* toUnits,
    47                                     double val,
    48                                     int* result );
    49 
     67    int add_presets(const char* presetName);
    5068
    5169#ifdef __cplusplus
  • trunk/include/core/RpUnits.h

    r73 r76  
    321321               
    322322        };
    323 
     323       
     324        /*
     325        RpUnits& operator= (const RpUnits& myRpUnit) {
     326
     327            if ( this != &myRpUnit ) {
     328                delete head;
     329                delete convList;
     330                delete conv;
     331            }
     332        }
     333        */
     334       
    324335    private:
    325336
     
    348359
    349360        // dictionary to store the units.
    350         // dict pointer
    351         // static RpDict<std::string,RpUnits*> dict;
    352361        static RpDict<std::string,RpUnits*>* dict;
    353362
     
    359368        //      of the units (the fundamental unit)
    360369        //
     370
     371
     372
    361373        RpUnits (
    362374                    const std::string& units,
     
    372384        // create a conversion element
    373385
     386
     387
     388       
    374389        RpUnits (
    375390                    RpUnits* from,
     
    389404        };
    390405
     406
     407
     408
     409       
    391410        RpUnits (
    392411                    RpUnits* from,
     
    414433        // default destructor
    415434        //
    416         //~RpUnits ();
    417435        ~RpUnits ()
    418436        {
  • trunk/src/Makefile

    r73 r76  
    2727#
    2828CC                              = gcc
    29 CPP                             = g++
     29CXX                             = g++
    3030DEBUG                   = -g -Wall
    3131DEBUG_PLUS              = -g -DDEBUG
     
    9393#### librappture shared object ###########################################
    9494
    95 librappture: rappture_fortran.o rappture_interface.o RpUnitsCInterface.o RpUnitsStd.o RpUnits.o
    96         $(CPP) $(DEGUG) -shared -Wl,-rpath,$(LIB_DIR)/ \
     95librappture: rappture_fortran.o rappture_interface.o RpUnitsCInterface.o RpUnitsFInterface.o RpFortranCommon.o RpUnitsStd.o RpUnits.o
     96        $(CXX) $(DEGUG) -shared -Wl,-rpath,$(LIB_DIR)/ \
    9797                -Wl,-soname,$@.so -o $(LIB_DIR)/$@.so.0.0 $^ $(EMB_PY_FLAGS)
    9898
     
    102102#### libRpObjects ########################################################
    103103libRpObjects: RpVariable.o RpAbout.o RpNumber.o RpString.o RpBoolean.o RpChoice.o RpOption.o RpUnitsStd.o RpUnits.o
    104         $(CPP) $(DEGUG) -shared -Wl,-rpath,$(LIB_DIR)/ \
     104        $(CXX) $(DEGUG) -shared -Wl,-rpath,$(LIB_DIR)/ \
    105105                -Wl,-soname,$@.so -o $(LIB_DIR)/$@.so.0.0 $^ -lc
    106106       
     
    110110# include core source files
    111111
    112 Rp%.o: $(CORE_SRC)/Rp%.cc
    113         $(CPP) -fPIC $(DEBUG) $(INCL_CORE) -o $@ -c $?
     112RpVariable.o: $(CORE_SRC)/RpVariable.cc
     113        $(CXX) -fPIC $(DEBUG) $(INCL_CORE) -o $@ -c $?
     114
     115RpAbout.o: $(CORE_SRC)/RpAbout.cc
     116        $(CXX) -fPIC $(DEBUG) $(INCL_CORE) -o $@ -c $?
     117
     118RpNumber.o: $(CORE_SRC)/RpNumber.cc
     119        $(CXX) -fPIC $(DEBUG) $(INCL_CORE) -o $@ -c $?
     120
     121RpString.o: $(CORE_SRC)/RpString.cc
     122        $(CXX) -fPIC $(DEBUG) $(INCL_CORE) -o $@ -c $?
     123
     124RpBoolean.o: $(CORE_SRC)/RpBoolean.cc
     125        $(CXX) -fPIC $(DEBUG) $(INCL_CORE) -o $@ -c $?
     126
     127RpChoice.o: $(CORE_SRC)/RpChoice.cc
     128        $(CXX) -fPIC $(DEBUG) $(INCL_CORE) -o $@ -c $?
     129
     130RpOption.o: $(CORE_SRC)/RpOption.cc
     131        $(CXX) -fPIC $(DEBUG) $(INCL_CORE) -o $@ -c $?
     132
     133RpUnitsStd.o: $(CORE_SRC)/RpUnitsStd.cc
     134        $(CXX) -fPIC $(DEBUG) $(INCL_CORE) -o $@ -c $?
     135
     136RpUnits.o: $(CORE_SRC)/RpUnits.cc
     137        $(CXX) -fPIC $(DEBUG) $(INCL_CORE) -o $@ -c $?
     138
     139
     140
    114141
    115142# include cee binding definitions
    116143
    117144rappture_interface.o: $(CEE_SRC)/rappture_interface.c
    118         $(CPP) -fPIC $(DEBUG) $(INCL_CEE) $(INCL_PY) -o $@ -c $<
     145        $(CXX) -fPIC $(DEBUG) $(INCL_CEE) $(INCL_PY) -o $@ -c $<
    119146
    120147RpUnitsCInterface.o: $(CEE_SRC)/RpUnitsCInterface.cc
    121         $(CPP) $(CFLAGS) -fPIC $(DEBUG) $(INCL_CORE) $(INCL_CEE) -o $@ -c $?
     148        $(CXX) $(CFLAGS) -fPIC $(DEBUG) $(INCL_CORE) $(INCL_CEE) -o $@ -c $?
     149
     150
     151
    122152
    123153# include fortran binding definitions
    124154
    125 RpUnits_fortran.o: $(FORT_SRC)/RpUnits_fortran.c
    126         $(CPP) $(CFLAGS) -fPIC $(DEBUG) $(INCL_CORE) -o $@ -c $?
     155rappture_fortran.o: $(FORT_SRC)/rappture_fortran.c
     156        $(CXX) $(CFLAGS) -fPIC $(DEBUG) $(INCL_FORTRAN) $(INCL_CORE) $(INCL_CEE) $(INCL_PY) -o $@ -c $<
    127157
    128 rappture_fortran.o: $(FORT_SRC)/rappture_fortran.c
    129         $(CPP) $(CFLAGS) -fPIC $(DEBUG) $(INCL_CORE) $(INCL_CEE) $(INCL_PY) -o $@ -c $<
     158RpUnitsFInterface.o: $(FORT_SRC)/RpUnitsFInterface.cc
     159        $(CXX) $(CFLAGS) -fPIC $(DEBUG) $(INCL_CORE) $(INCL_FORTRAN) -o $@ -c $?
     160
     161RpFortranCommon.o: $(FORT_SRC)/RpFortranCommon.c
     162        $(CC) $(CFLAGS) -fPIC $(DEBUG) $(INCL_FORTRAN) -o $@ -c $<
     163
     164
     165
    130166
    131167#### CLEAN UP ############################################################
  • trunk/src/cee/RpUnitsCInterface.cc

    r21 r76  
    66#endif
    77
    8     RpUnits* defineUnit(const char* unitSymbol, RpUnits* basis)
    9     {
     8    RpUnits* defineUnit(const char* unitSymbol, RpUnits* basis) {
     9       
    1010        return RpUnits::define(unitSymbol, basis);
    1111    }
     
    1414                            RpUnits* toUnit,
    1515                            double (*convForwFxnPtr)(double),
    16                             double (*convBackFxnPtr)(double)    )
    17     {
     16                            double (*convBackFxnPtr)(double)    ) {
     17
    1818        return RpUnits::define(fromUnit,toUnit,convForwFxnPtr,convBackFxnPtr);
    1919    }
    2020
    21     RpUnits* find(const char* key)
    22     {
     21    RpUnits* find(const char* key) {
     22       
    2323        return RpUnits::find(key);
    2424    }
    2525
    26     const char* getUnits(RpUnits* unit)
    27     {
    28         return unit->getUnits().c_str();
     26    const char* getUnits(RpUnits* unit) {
     27       
     28        static std::string retVal;
     29        retVal = unit->getUnits();
     30        return retVal.c_str();
    2931    }
    3032
    31     const char* getUnitsName(RpUnits* unit)
    32     {
    33         return unit->getUnitsName().c_str();
     33    const char* getUnitsName(RpUnits* unit) {
     34       
     35        static std::string retVal;
     36        retVal = unit->getUnitsName();
     37        return retVal.c_str();
    3438    }
    3539
    36     double getExponent(RpUnits* unit)
    37     {
     40    double getExponent(RpUnits* unit) {
     41
    3842        return unit->getExponent();
    3943    }
    4044
    41     RpUnits* getBasis(RpUnits* unit)
    42     {
     45    RpUnits* getBasis(RpUnits* unit) {
     46       
    4347        return unit->getBasis();
    4448    }
    4549
    46     int makeMetric(RpUnits* basis)
    47     {
     50    int makeMetric(RpUnits* basis) {
     51
    4852        return RpUnits::makeMetric(basis);
    4953    }
    5054
    51     const char* convert_str(    RpUnits* fromUnits,
    52                                 RpUnits* toUnits,
    53                                 double val,
    54                                 int showUnits   )
    55     {
    56         return convert_str_result(fromUnits,toUnits,val,showUnits,NULL);
     55    const char* convert (   const char* fromVal,
     56                            const char* toUnitsName,
     57                            int showUnits,
     58                            int* result ) {
     59
     60        static std::string retVal;
     61        retVal = RpUnits::convert(fromVal,toUnitsName,showUnits,result);
     62        return retVal.c_str();
     63    }
     64
     65    const char* convert_str (   const char* fromVal,
     66                                const char* toUnitsName,
     67                                int showUnits,
     68                                int* result ) {
     69
     70        static std::string retVal;
     71        retVal = RpUnits::convert(fromVal,toUnitsName,showUnits,result);
     72        return retVal.c_str();
     73    }
     74
     75    const char* convert_obj_str(    RpUnits* fromUnits,
     76                                    RpUnits* toUnits,
     77                                    double val,
     78                                    int showUnits   ) {
     79
     80        return convert_obj_str_result(fromUnits,toUnits,val,showUnits,NULL);
    5781    }
    5882   
    59     const char* convert_str_result( RpUnits* fromUnits,
    60                                     RpUnits* toUnits,
    61                                     double val,
    62                                     int showUnits,
    63                                     int* result )
    64     {
    65         return fromUnits->convert(toUnits,val,showUnits,result).c_str();
     83    const char* convert_obj_str_result( RpUnits* fromUnits,
     84                                        RpUnits* toUnits,
     85                                        double val,
     86                                        int showUnits,
     87                                        int* result ) {
     88       
     89        static std::string retVal;
     90        retVal = fromUnits->convert(toUnits,val,showUnits,result);
     91        return retVal.c_str();
    6692    }
    6793
    68     double convert_double(RpUnits* fromUnits, RpUnits* toUnits, double val)
    69     {
    70         return convert_double_result(fromUnits,toUnits,val,NULL);
     94    double convert_dbl (    const char* fromVal,
     95                            const char* toUnitsName,
     96                            int* result ) {
     97
     98        std::string convStr;
     99        double retVal = 0.0;
     100
     101        convStr = RpUnits::convert(fromVal,toUnitsName,0,result);
     102
     103        if (!convStr.empty()) {
     104            retVal = atof(convStr.c_str());
     105        }
     106
     107        return retVal;
    71108    }
    72109
    73     double convert_double_result(   RpUnits* fromUnits,
    74                                     RpUnits* toUnits,
    75                                     double val,
    76                                     int* result )
    77     {
     110    double convert_obj_double(  RpUnits* fromUnits,
     111                                RpUnits* toUnits,
     112                                double val  ) {
     113
     114        return convert_obj_double_result(fromUnits,toUnits,val,NULL);
     115    }
     116
     117    double convert_obj_double_result(   RpUnits* fromUnits,
     118                                        RpUnits* toUnits,
     119                                        double val,
     120                                        int* result ) {
     121       
    78122        return fromUnits->convert(toUnits,val,result);
     123    }
     124
     125    int add_presets ( const char* presetName ) {
     126
     127        return RpUnits::addPresets(presetName);
    79128    }
    80129
  • trunk/src/core/RpUnits.cc

    r73 r76  
    511511{
    512512    return head->getExponent();
    513     return 0;
    514513}
    515514
     
    792791    if (this->getUnits() == toUnit->getUnits()) {
    793792        if (result) {
    794             *result = 1;
     793            *result = 0;
    795794        }
    796795        return val;
     
    843842            value = p->conv->convForwFxnPtr(value);
    844843            if (result) {
    845                 *result = 1;
     844                *result = 0;
    846845            }
    847846            break;
     
    854853            value = p->conv->convBackFxnPtr(value);
    855854            if (result) {
    856                 *result = 1;
     855                *result = 0;
    857856            }
    858857            break;
     
    898897    if (this->getUnits() == toUnit->getUnits()) {
    899898        if (result) {
    900             *result = 1;
     899            *result = 0;
    901900        }
    902901        return val;
     
    950949
    951950            if (result) {
    952                 *result = 1;
     951                *result = 0;
    953952            }
    954953            break;
     
    961960            value = p->conv->convBackFxnPtrVoid(p->conv->convBackData,value);
    962961            if (result) {
    963                 *result = 1;
     962                *result = 0;
    964963            }
    965964            break;
     
    11471146int
    11481147RpUnits::addPresets (std::string group) {
    1149     int retVal = 1;
     1148    int retVal = -1;
    11501149    if (group.compare("all") == 0) {
    11511150        retVal = addPresetAll();
     
    11711170RpUnits::addPresetAll () {
    11721171
    1173 
    1174     addPresetTime();
    1175     addPresetTemp();
    1176     addPresetLength();
    1177     addPresetEnergy();
     1172    int result = 0;
     1173
     1174    result += addPresetTime();
     1175    result += addPresetTemp();
     1176    result += addPresetLength();
     1177    result += addPresetEnergy();
    11781178
    11791179    return 0;
  • trunk/src/fortran/rappture_fortran.c

    r66 r76  
    11#include "rappture_interface.h"
     2#include "RpFortranCommon.h"
    23#include "RpDict.h"
    34#include <string.h>
     
    294295int storeObject(PyObject* objectName);
    295296PyObject* getObject(int objKey);
    296 char* null_terminate(char* inStr, int len);
     297// char* null_terminate(char* inStr, int len);
    297298
    298299// global vars
     
    483484                        )
    484485{
    485     int length_in = 0;
    486     int length_out = 0;
    487     int i = 0;
     486    // int length_in = 0;
     487    // int length_out = 0;
     488    // int i = 0;
    488489    const char* xmlText = NULL;
    489490
     
    509510                        xmlText = retObj;
    510511                   
     512                        fortranify(xmlText, retText, retText_len);
     513           
     514                        /*
    511515                        length_in = strlen(xmlText);
    512516                        length_out = retText_len;
     
    521525                        }
    522526                        *(retText+length_out-1) = ' ';
     527                        */
    523528                       
    524529                        free(retObj);
     
    768773{
    769774    int retVal = 0;
    770     int i = 0;
    771     int length_in = 0;
     775    // int i = 0;
     776    // int length_in = 0;
    772777
    773778    PyObject* lib = NULL;
     
    802807                            // printf("xmlChild = :%s:\n",xmlChild);
    803808                            if (xmlChild) {
     809                                fortranify(xmlChild, retText, retText_len);
     810
     811                                /*
    804812                                strncpy(retText, xmlChild, retText_len);
    805813                                length_in = strlen(xmlChild);
     
    812820                                }
    813821                                // *(retText+retText_len-1) = ' ';
     822                                */
    814823                            }
    815824                        }
     
    901910                 )
    902911{
    903     int length_in = 0;
    904     int length_out = 0;
    905     int i = 0;
     912    // int length_in = 0;
     913    // int length_out = 0;
     914    // int i = 0;
    906915    const char* xmlText = NULL;
    907916
     
    923932                if (xmlText) {
    924933
     934                    fortranify(xmlText, retText, retText_len);
     935                   
     936                    /*
    925937                    length_in = strlen(xmlText);
    926938                    length_out = retText_len;
     
    935947                    }
    936948                    *(retText+length_out-1) = ' ';
     949                    */
    937950                }
    938951
     
    12101223void  rp_lib_xml(int* handle, char* retText, int retText_len)
    12111224{
    1212     int length_in = 0;
    1213     int length_out = 0;
    1214     int i = 0;
     1225    // int length_in = 0;
     1226    // int length_out = 0;
     1227    // int i = 0;
    12151228    char* xmlText = NULL;
    12161229
     
    12251238               
    12261239                if (xmlText) {
     1240
     1241                    fortranify(xmlText, retText, retText_len);
     1242
     1243                    /*
    12271244                    length_in = strlen(xmlText);
    12281245                    length_out = retText_len;
     
    12371254                    }
    12381255                    *(retText+length_out-1) = ' ';
     1256                    */
    12391257
    12401258                    free(xmlText);
     
    13801398
    13811399}
    1382 
    1383 /* fix buffer overflow possibility*/
    1384 char* null_terminate(char* inStr, int len)
    1385 {
    1386     int retVal = 0;
    1387     char* newStr = NULL;
    1388     char* current = NULL;
    1389 
    1390     if (inStr) {
    1391 
    1392         current = inStr+len-1;
    1393 
    1394         while ((len > 0) && (isspace(*(current)))) {
    1395             // dont strip off newlines
    1396 
    1397             if ( (*(current) == '\f')
    1398               || (*(current) == '\n')
    1399               || (*(current) == '\r')
    1400               || (*(current) == '\t')
    1401               || (*(current) == '\v') )
    1402             {
    1403                 break;
    1404             }
    1405 
    1406             if (--len) {
    1407                 current--;
    1408             }
    1409         }
    1410 
    1411         newStr = (char*) calloc(len+1,(sizeof(char)));
    1412         strncpy(newStr,inStr,len);
    1413         *(newStr+len) = '\0';
    1414 
    1415         retVal++;
    1416     }
    1417 
    1418     // return retVal;
    1419 
    1420     return newStr;
    1421 }
  • trunk/test/src/RpUnitsC_test.c

    r40 r76  
     1//----------------------------------------------------------------------
     2// TEST: Cee's interface to RpUnits.
     3//
     4// Basic units conversion tests for the RpUnits portion of Rappture
     5// written in Cee.
     6//======================================================================
     7// AUTHOR:  Derrick Kearney, Purdue University
     8// Copyright (c) 2004-2005
     9// Purdue Research Foundation, West Lafayette, IN
     10//======================================================================
     11//
    112#include "RpUnitsCInterface.h"
    213#include <stdio.h>
     
    6374    int showUnits = 0;
    6475
    65     const char* nm_conv_str;
     76    const char* nm_conv_str = NULL;
     77    const char* retStr = NULL;
    6678   
    6779    makeMetric(meters);
     
    92104    if (nanometers) {
    93105
    94         nm_conv = convert_double_result(nanometers,meters,1.0e9,&result);
     106        nm_conv = convert_obj_double_result(nanometers,meters,1.0e9,&result);
    95107        printf("1.0e9 nm = %f m\tresult = %d\n",nm_conv,result);
    96108
    97         nm_conv = convert_double(nanometers,meters,1.0e9);
     109        nm_conv = convert_obj_double(nanometers,meters,1.0e9);
    98110        printf("1.0e9 nm = %f m\n",nm_conv);
    99111
    100112        showUnits = 1;
    101         nm_conv_str = convert_str(nanometers,meters,1.588e9,showUnits);
     113        nm_conv_str = convert_obj_str(nanometers,meters,1.588e9,showUnits);
    102114        printf("1.588e9 nm = %s\n",nm_conv_str);
    103115
    104116        showUnits = 0;
    105         nm_conv_str = convert_str(nanometers,meters,1.588e9,showUnits);
     117        nm_conv_str = convert_obj_str(nanometers,meters,1.588e9,showUnits);
    106118        printf("1.588e9 nm = %s\n",nm_conv_str);
    107119    }
     
    111123
    112124    if (meters && angstrom && centimeters) {
    113         value = convert_double_result(angstrom,meters,1.0,&result);
     125        value = convert_obj_double_result(angstrom,meters,1.0,&result);
    114126        printf("1 angstrom = %e meters\n",value);
    115127
    116         value = convert_double_result(centimeters,angstrom,1e-8,&result);
     128        value = convert_obj_double_result(centimeters,angstrom,1e-8,&result);
    117129        printf("1.0e-8 centimeter = %f angstroms\n",value);
    118130    }
     
    123135
    124136    if (fahrenheit && celcius) {
    125         value = convert_double_result(fahrenheit,celcius,72,&result);
     137        value = convert_obj_double_result(fahrenheit,celcius,72,&result);
    126138        printf("72 degrees fahrenheit = %f degrees celcius\n",value);
    127139   
    128         value = convert_double_result(celcius,fahrenheit,value,&result);
     140        value = convert_obj_double_result(celcius,fahrenheit,value,&result);
    129141        printf("22.222 degrees celcius = %f degrees fahrenheit\n",value);
    130142    }
     
    134146       
    135147    if (celcius && kelvin) {
    136         value = convert_double_result(celcius,kelvin,20,&result);
     148        value = convert_obj_double_result(celcius,kelvin,20,&result);
    137149        printf("20 degrees celcius = %f kelvin\n",value);
    138150
    139         value = convert_double_result(kelvin,celcius,300,&result);
     151        value = convert_obj_double_result(kelvin,celcius,300,&result);
    140152        printf("300 kelvin = %f degrees celcius\n", value);
    141153    }
     
    144156    }
    145157
     158    printf("====== adding all preset units ======\n");
     159    add_presets("all");
     160
     161    printf("====== TESTING STATIC CONVERT FXNS ======\n");
     162
     163    retStr = convert("72F","C",1,&result);
     164    printf("72F = %s\tresult = %d\n", retStr,result);
     165
     166    retStr = convert("300K","F",1,&result);
     167    printf("300K = %s\tresult = %d\n", retStr,result);
     168
     169    retStr = convert("1eV","J",0,&result);
     170    printf("1eV = %s (no units)\tresult = %d\n", retStr,result);
     171
     172    retStr = convert_str("300K","R",1,&result);
     173    printf("300K = %s\tresult = %d\n", retStr,result);
     174
     175    retStr = convert_str("5m","ft",1,&result);
     176    printf("5m = %s\tresult = %d\n", retStr,result);
     177
     178    value = convert_dbl("5000mV","V",&result);
     179    printf("5V = %f (double value)\n", value);
     180
     181   
    146182    return 0;
    147183}
Note: See TracChangeset for help on using the changeset viewer.