Ignore:
Timestamp:
03/24/15 11:21:45 (9 years ago)
Author:
rlacroix
Message:

Fix the Fortran interface generation to avoid generating dead code that caused a timer not to be stopped.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS/trunk/src/interface/c_attr/icfile_attr.cpp

    r538 r581  
    11/* ************************************************************************** * 
    2  *               Interface auto generated - do not modify                   * 
     2 *               Interface auto generated - do not modify                     * 
    33 * ************************************************************************** */ 
    44 
    … …  
    1616extern "C" 
    1717{ 
    18   typedef xios::CFile*  file_Ptr; 
    19    
     18  typedef xios::CFile* file_Ptr; 
     19 
    2020  void cxios_set_file_append(file_Ptr file_hdl, bool append) 
    2121  { 
    22      CTimer::get("XIOS").resume(); 
     22    CTimer::get("XIOS").resume(); 
    2323    file_hdl->append.setValue(append); 
    24      CTimer::get("XIOS").suspend(); 
    25   } 
    26    
     24    CTimer::get("XIOS").suspend(); 
     25  } 
     26 
    2727  void cxios_get_file_append(file_Ptr file_hdl, bool* append) 
    2828  { 
     29    CTimer::get("XIOS").resume(); 
    2930    *append = file_hdl->append.getInheritedValue(); 
    30   } 
    31    
    32   bool cxios_is_defined_file_append(file_Ptr file_hdl ) 
    33   { 
    34      CTimer::get("XIOS").resume(); 
    35     return file_hdl->append.hasInheritedValue(); 
    36      CTimer::get("XIOS").suspend(); 
    37   } 
    38    
    39    
    40    
     31    CTimer::get("XIOS").suspend(); 
     32  } 
     33 
     34  bool cxios_is_defined_file_append(file_Ptr file_hdl) 
     35  { 
     36     CTimer::get("XIOS").resume(); 
     37     bool isDefined = file_hdl->append.hasInheritedValue(); 
     38     CTimer::get("XIOS").suspend(); 
     39     return isDefined; 
     40  } 
     41 
     42 
    4143  void cxios_set_file_description(file_Ptr file_hdl, const char * description, int description_size) 
    4244  { 
    4345    std::string description_str; 
    44     if(!cstr2string(description, description_size, description_str)) return; 
    45      CTimer::get("XIOS").resume(); 
     46    if (!cstr2string(description, description_size, description_str)) return; 
     47    CTimer::get("XIOS").resume(); 
    4648    file_hdl->description.setValue(description_str); 
    47      CTimer::get("XIOS").suspend(); 
    48   } 
    49    
     49    CTimer::get("XIOS").suspend(); 
     50  } 
     51 
    5052  void cxios_get_file_description(file_Ptr file_hdl, char * description, int description_size) 
    5153  { 
    52      CTimer::get("XIOS").resume(); 
    53     if(!string_copy(file_hdl->description.getInheritedValue(),description , description_size)) 
    54       ERROR("void cxios_get_file_description(file_Ptr file_hdl, char * description, int description_size)", <<"Input string is to short"); 
    55      CTimer::get("XIOS").suspend(); 
    56   } 
    57    
    58   bool cxios_is_defined_file_description(file_Ptr file_hdl ) 
    59   { 
    60      CTimer::get("XIOS").resume(); 
    61     return file_hdl->description.hasInheritedValue(); 
    62      CTimer::get("XIOS").suspend(); 
    63   } 
    64    
    65    
    66    
     54    CTimer::get("XIOS").resume(); 
     55    if (!string_copy(file_hdl->description.getInheritedValue(), description, description_size)) 
     56      ERROR("void cxios_get_file_description(file_Ptr file_hdl, char * description, int description_size)", << "Input string is too short"); 
     57    CTimer::get("XIOS").suspend(); 
     58  } 
     59 
     60  bool cxios_is_defined_file_description(file_Ptr file_hdl) 
     61  { 
     62     CTimer::get("XIOS").resume(); 
     63     bool isDefined = file_hdl->description.hasInheritedValue(); 
     64     CTimer::get("XIOS").suspend(); 
     65     return isDefined; 
     66  } 
     67 
     68 
    6769  void cxios_set_file_enabled(file_Ptr file_hdl, bool enabled) 
    6870  { 
    69      CTimer::get("XIOS").resume(); 
     71    CTimer::get("XIOS").resume(); 
    7072    file_hdl->enabled.setValue(enabled); 
    71      CTimer::get("XIOS").suspend(); 
    72   } 
    73    
     73    CTimer::get("XIOS").suspend(); 
     74  } 
     75 
    7476  void cxios_get_file_enabled(file_Ptr file_hdl, bool* enabled) 
    7577  { 
     78    CTimer::get("XIOS").resume(); 
    7679    *enabled = file_hdl->enabled.getInheritedValue(); 
    77   } 
    78    
    79   bool cxios_is_defined_file_enabled(file_Ptr file_hdl ) 
    80   { 
    81      CTimer::get("XIOS").resume(); 
    82     return file_hdl->enabled.hasInheritedValue(); 
    83      CTimer::get("XIOS").suspend(); 
    84   } 
    85    
    86    
    87    
     80    CTimer::get("XIOS").suspend(); 
     81  } 
     82 
     83  bool cxios_is_defined_file_enabled(file_Ptr file_hdl) 
     84  { 
     85     CTimer::get("XIOS").resume(); 
     86     bool isDefined = file_hdl->enabled.hasInheritedValue(); 
     87     CTimer::get("XIOS").suspend(); 
     88     return isDefined; 
     89  } 
     90 
     91 
    8892  void cxios_set_file_format(file_Ptr file_hdl, const char * format, int format_size) 
    8993  { 
    9094    std::string format_str; 
    91     if(!cstr2string(format, format_size, format_str)) return; 
    92      CTimer::get("XIOS").resume(); 
     95    if (!cstr2string(format, format_size, format_str)) return; 
     96    CTimer::get("XIOS").resume(); 
    9397    file_hdl->format.fromString(format_str); 
    94      CTimer::get("XIOS").suspend(); 
    95   } 
    96    
     98    CTimer::get("XIOS").suspend(); 
     99  } 
     100 
    97101  void cxios_get_file_format(file_Ptr file_hdl, char * format, int format_size) 
    98102  { 
    99      CTimer::get("XIOS").resume(); 
    100     if(!string_copy(file_hdl->format.getInheritedStringValue(),format , format_size)) 
    101       ERROR("void cxios_get_file_format(file_Ptr file_hdl, char * format, int format_size)", <<"Input string is to short"); 
    102      CTimer::get("XIOS").suspend(); 
    103   } 
    104    
    105   bool cxios_is_defined_file_format(file_Ptr file_hdl ) 
    106   { 
    107      CTimer::get("XIOS").resume(); 
    108     return file_hdl->format.hasInheritedValue(); 
    109      CTimer::get("XIOS").suspend(); 
    110   } 
    111    
    112    
    113    
     103    CTimer::get("XIOS").resume(); 
     104    if (!string_copy(file_hdl->format.getInheritedStringValue(), format, format_size)) 
     105      ERROR("void cxios_get_file_format(file_Ptr file_hdl, char * format, int format_size)", << "Input string is too short"); 
     106    CTimer::get("XIOS").suspend(); 
     107  } 
     108 
     109  bool cxios_is_defined_file_format(file_Ptr file_hdl) 
     110  { 
     111     CTimer::get("XIOS").resume(); 
     112     bool isDefined = file_hdl->format.hasInheritedValue(); 
     113     CTimer::get("XIOS").suspend(); 
     114     return isDefined; 
     115  } 
     116 
     117 
    114118  void cxios_set_file_min_digits(file_Ptr file_hdl, int min_digits) 
    115119  { 
    116      CTimer::get("XIOS").resume(); 
     120    CTimer::get("XIOS").resume(); 
    117121    file_hdl->min_digits.setValue(min_digits); 
    118      CTimer::get("XIOS").suspend(); 
    119   } 
    120    
     122    CTimer::get("XIOS").suspend(); 
     123  } 
     124 
    121125  void cxios_get_file_min_digits(file_Ptr file_hdl, int* min_digits) 
    122126  { 
     127    CTimer::get("XIOS").resume(); 
    123128    *min_digits = file_hdl->min_digits.getInheritedValue(); 
    124   } 
    125    
    126   bool cxios_is_defined_file_min_digits(file_Ptr file_hdl ) 
    127   { 
    128      CTimer::get("XIOS").resume(); 
    129     return file_hdl->min_digits.hasInheritedValue(); 
    130      CTimer::get("XIOS").suspend(); 
    131   } 
    132    
    133    
    134    
     129    CTimer::get("XIOS").suspend(); 
     130  } 
     131 
     132  bool cxios_is_defined_file_min_digits(file_Ptr file_hdl) 
     133  { 
     134     CTimer::get("XIOS").resume(); 
     135     bool isDefined = file_hdl->min_digits.hasInheritedValue(); 
     136     CTimer::get("XIOS").suspend(); 
     137     return isDefined; 
     138  } 
     139 
     140 
    135141  void cxios_set_file_name(file_Ptr file_hdl, const char * name, int name_size) 
    136142  { 
    137143    std::string name_str; 
    138     if(!cstr2string(name, name_size, name_str)) return; 
    139      CTimer::get("XIOS").resume(); 
     144    if (!cstr2string(name, name_size, name_str)) return; 
     145    CTimer::get("XIOS").resume(); 
    140146    file_hdl->name.setValue(name_str); 
    141      CTimer::get("XIOS").suspend(); 
    142   } 
    143    
     147    CTimer::get("XIOS").suspend(); 
     148  } 
     149 
    144150  void cxios_get_file_name(file_Ptr file_hdl, char * name, int name_size) 
    145151  { 
    146      CTimer::get("XIOS").resume(); 
    147     if(!string_copy(file_hdl->name.getInheritedValue(),name , name_size)) 
    148       ERROR("void cxios_get_file_name(file_Ptr file_hdl, char * name, int name_size)", <<"Input string is to short"); 
    149      CTimer::get("XIOS").suspend(); 
    150   } 
    151    
    152   bool cxios_is_defined_file_name(file_Ptr file_hdl ) 
    153   { 
    154      CTimer::get("XIOS").resume(); 
    155     return file_hdl->name.hasInheritedValue(); 
    156      CTimer::get("XIOS").suspend(); 
    157   } 
    158    
    159    
    160    
     152    CTimer::get("XIOS").resume(); 
     153    if (!string_copy(file_hdl->name.getInheritedValue(), name, name_size)) 
     154      ERROR("void cxios_get_file_name(file_Ptr file_hdl, char * name, int name_size)", << "Input string is too short"); 
     155    CTimer::get("XIOS").suspend(); 
     156  } 
     157 
     158  bool cxios_is_defined_file_name(file_Ptr file_hdl) 
     159  { 
     160     CTimer::get("XIOS").resume(); 
     161     bool isDefined = file_hdl->name.hasInheritedValue(); 
     162     CTimer::get("XIOS").suspend(); 
     163     return isDefined; 
     164  } 
     165 
     166 
    161167  void cxios_set_file_name_suffix(file_Ptr file_hdl, const char * name_suffix, int name_suffix_size) 
    162168  { 
    163169    std::string name_suffix_str; 
    164     if(!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return; 
    165      CTimer::get("XIOS").resume(); 
     170    if (!cstr2string(name_suffix, name_suffix_size, name_suffix_str)) return; 
     171    CTimer::get("XIOS").resume(); 
    166172    file_hdl->name_suffix.setValue(name_suffix_str); 
    167      CTimer::get("XIOS").suspend(); 
    168   } 
    169    
     173    CTimer::get("XIOS").suspend(); 
     174  } 
     175 
    170176  void cxios_get_file_name_suffix(file_Ptr file_hdl, char * name_suffix, int name_suffix_size) 
    171177  { 
    172      CTimer::get("XIOS").resume(); 
    173     if(!string_copy(file_hdl->name_suffix.getInheritedValue(),name_suffix , name_suffix_size)) 
    174       ERROR("void cxios_get_file_name_suffix(file_Ptr file_hdl, char * name_suffix, int name_suffix_size)", <<"Input string is to short"); 
    175      CTimer::get("XIOS").suspend(); 
    176   } 
    177    
    178   bool cxios_is_defined_file_name_suffix(file_Ptr file_hdl ) 
    179   { 
    180      CTimer::get("XIOS").resume(); 
    181     return file_hdl->name_suffix.hasInheritedValue(); 
    182      CTimer::get("XIOS").suspend(); 
    183   } 
    184    
    185    
    186    
     178    CTimer::get("XIOS").resume(); 
     179    if (!string_copy(file_hdl->name_suffix.getInheritedValue(), name_suffix, name_suffix_size)) 
     180      ERROR("void cxios_get_file_name_suffix(file_Ptr file_hdl, char * name_suffix, int name_suffix_size)", << "Input string is too short"); 
     181    CTimer::get("XIOS").suspend(); 
     182  } 
     183 
     184  bool cxios_is_defined_file_name_suffix(file_Ptr file_hdl) 
     185  { 
     186     CTimer::get("XIOS").resume(); 
     187     bool isDefined = file_hdl->name_suffix.hasInheritedValue(); 
     188     CTimer::get("XIOS").suspend(); 
     189     return isDefined; 
     190  } 
     191 
     192 
    187193  void cxios_set_file_output_freq(file_Ptr file_hdl, cxios_duration output_freq_c) 
    188194  { 
    … …  
    199205    CTimer::get("XIOS").suspend(); 
    200206  } 
    201    
     207 
    202208  void cxios_get_file_output_freq(file_Ptr file_hdl, cxios_duration* output_freq_c) 
    203209  { 
    … …  
    213219    CTimer::get("XIOS").suspend(); 
    214220  } 
    215    
    216   bool cxios_is_defined_file_output_freq(file_Ptr file_hdl ) 
    217   { 
    218      CTimer::get("XIOS").resume(); 
    219     return file_hdl->output_freq.hasInheritedValue(); 
    220      CTimer::get("XIOS").suspend(); 
    221   } 
    222    
    223    
    224    
     221 
     222  bool cxios_is_defined_file_output_freq(file_Ptr file_hdl) 
     223  { 
     224     CTimer::get("XIOS").resume(); 
     225     bool isDefined = file_hdl->output_freq.hasInheritedValue(); 
     226     CTimer::get("XIOS").suspend(); 
     227     return isDefined; 
     228  } 
     229 
     230 
    225231  void cxios_set_file_output_level(file_Ptr file_hdl, int output_level) 
    226232  { 
    227      CTimer::get("XIOS").resume(); 
     233    CTimer::get("XIOS").resume(); 
    228234    file_hdl->output_level.setValue(output_level); 
    229      CTimer::get("XIOS").suspend(); 
    230   } 
    231    
     235    CTimer::get("XIOS").suspend(); 
     236  } 
     237 
    232238  void cxios_get_file_output_level(file_Ptr file_hdl, int* output_level) 
    233239  { 
     240    CTimer::get("XIOS").resume(); 
    234241    *output_level = file_hdl->output_level.getInheritedValue(); 
    235   } 
    236    
    237   bool cxios_is_defined_file_output_level(file_Ptr file_hdl ) 
    238   { 
    239      CTimer::get("XIOS").resume(); 
    240     return file_hdl->output_level.hasInheritedValue(); 
    241      CTimer::get("XIOS").suspend(); 
    242   } 
    243    
    244    
    245    
     242    CTimer::get("XIOS").suspend(); 
     243  } 
     244 
     245  bool cxios_is_defined_file_output_level(file_Ptr file_hdl) 
     246  { 
     247     CTimer::get("XIOS").resume(); 
     248     bool isDefined = file_hdl->output_level.hasInheritedValue(); 
     249     CTimer::get("XIOS").suspend(); 
     250     return isDefined; 
     251  } 
     252 
     253 
    246254  void cxios_set_file_par_access(file_Ptr file_hdl, const char * par_access, int par_access_size) 
    247255  { 
    248256    std::string par_access_str; 
    249     if(!cstr2string(par_access, par_access_size, par_access_str)) return; 
    250      CTimer::get("XIOS").resume(); 
     257    if (!cstr2string(par_access, par_access_size, par_access_str)) return; 
     258    CTimer::get("XIOS").resume(); 
    251259    file_hdl->par_access.fromString(par_access_str); 
    252      CTimer::get("XIOS").suspend(); 
    253   } 
    254    
     260    CTimer::get("XIOS").suspend(); 
     261  } 
     262 
    255263  void cxios_get_file_par_access(file_Ptr file_hdl, char * par_access, int par_access_size) 
    256264  { 
    257      CTimer::get("XIOS").resume(); 
    258     if(!string_copy(file_hdl->par_access.getInheritedStringValue(),par_access , par_access_size)) 
    259       ERROR("void cxios_get_file_par_access(file_Ptr file_hdl, char * par_access, int par_access_size)", <<"Input string is to short"); 
    260      CTimer::get("XIOS").suspend(); 
    261   } 
    262    
    263   bool cxios_is_defined_file_par_access(file_Ptr file_hdl ) 
    264   { 
    265      CTimer::get("XIOS").resume(); 
    266     return file_hdl->par_access.hasInheritedValue(); 
    267      CTimer::get("XIOS").suspend(); 
    268   } 
    269    
    270    
    271    
     265    CTimer::get("XIOS").resume(); 
     266    if (!string_copy(file_hdl->par_access.getInheritedStringValue(), par_access, par_access_size)) 
     267      ERROR("void cxios_get_file_par_access(file_Ptr file_hdl, char * par_access, int par_access_size)", << "Input string is too short"); 
     268    CTimer::get("XIOS").suspend(); 
     269  } 
     270 
     271  bool cxios_is_defined_file_par_access(file_Ptr file_hdl) 
     272  { 
     273     CTimer::get("XIOS").resume(); 
     274     bool isDefined = file_hdl->par_access.hasInheritedValue(); 
     275     CTimer::get("XIOS").suspend(); 
     276     return isDefined; 
     277  } 
     278 
     279 
    272280  void cxios_set_file_split_freq(file_Ptr file_hdl, cxios_duration split_freq_c) 
    273281  { 
    … …  
    284292    CTimer::get("XIOS").suspend(); 
    285293  } 
    286    
     294 
    287295  void cxios_get_file_split_freq(file_Ptr file_hdl, cxios_duration* split_freq_c) 
    288296  { 
    … …  
    298306    CTimer::get("XIOS").suspend(); 
    299307  } 
    300    
    301   bool cxios_is_defined_file_split_freq(file_Ptr file_hdl ) 
    302   { 
    303      CTimer::get("XIOS").resume(); 
    304     return file_hdl->split_freq.hasInheritedValue(); 
    305      CTimer::get("XIOS").suspend(); 
    306   } 
    307    
    308    
    309    
     308 
     309  bool cxios_is_defined_file_split_freq(file_Ptr file_hdl) 
     310  { 
     311     CTimer::get("XIOS").resume(); 
     312     bool isDefined = file_hdl->split_freq.hasInheritedValue(); 
     313     CTimer::get("XIOS").suspend(); 
     314     return isDefined; 
     315  } 
     316 
     317 
    310318  void cxios_set_file_split_freq_format(file_Ptr file_hdl, const char * split_freq_format, int split_freq_format_size) 
    311319  { 
    312320    std::string split_freq_format_str; 
    313     if(!cstr2string(split_freq_format, split_freq_format_size, split_freq_format_str)) return; 
    314      CTimer::get("XIOS").resume(); 
     321    if (!cstr2string(split_freq_format, split_freq_format_size, split_freq_format_str)) return; 
     322    CTimer::get("XIOS").resume(); 
    315323    file_hdl->split_freq_format.setValue(split_freq_format_str); 
    316      CTimer::get("XIOS").suspend(); 
    317   } 
    318    
     324    CTimer::get("XIOS").suspend(); 
     325  } 
     326 
    319327  void cxios_get_file_split_freq_format(file_Ptr file_hdl, char * split_freq_format, int split_freq_format_size) 
    320328  { 
    321      CTimer::get("XIOS").resume(); 
    322     if(!string_copy(file_hdl->split_freq_format.getInheritedValue(),split_freq_format , split_freq_format_size)) 
    323       ERROR("void cxios_get_file_split_freq_format(file_Ptr file_hdl, char * split_freq_format, int split_freq_format_size)", <<"Input string is to short"); 
    324      CTimer::get("XIOS").suspend(); 
    325   } 
    326    
    327   bool cxios_is_defined_file_split_freq_format(file_Ptr file_hdl ) 
    328   { 
    329      CTimer::get("XIOS").resume(); 
    330     return file_hdl->split_freq_format.hasInheritedValue(); 
    331      CTimer::get("XIOS").suspend(); 
    332   } 
    333    
    334    
    335    
     329    CTimer::get("XIOS").resume(); 
     330    if (!string_copy(file_hdl->split_freq_format.getInheritedValue(), split_freq_format, split_freq_format_size)) 
     331      ERROR("void cxios_get_file_split_freq_format(file_Ptr file_hdl, char * split_freq_format, int split_freq_format_size)", << "Input string is too short"); 
     332    CTimer::get("XIOS").suspend(); 
     333  } 
     334 
     335  bool cxios_is_defined_file_split_freq_format(file_Ptr file_hdl) 
     336  { 
     337     CTimer::get("XIOS").resume(); 
     338     bool isDefined = file_hdl->split_freq_format.hasInheritedValue(); 
     339     CTimer::get("XIOS").suspend(); 
     340     return isDefined; 
     341  } 
     342 
     343 
    336344  void cxios_set_file_sync_freq(file_Ptr file_hdl, cxios_duration sync_freq_c) 
    337345  { 
    … …  
    348356    CTimer::get("XIOS").suspend(); 
    349357  } 
    350    
     358 
    351359  void cxios_get_file_sync_freq(file_Ptr file_hdl, cxios_duration* sync_freq_c) 
    352360  { 
    … …  
    362370    CTimer::get("XIOS").suspend(); 
    363371  } 
    364    
    365   bool cxios_is_defined_file_sync_freq(file_Ptr file_hdl ) 
    366   { 
    367      CTimer::get("XIOS").resume(); 
    368     return file_hdl->sync_freq.hasInheritedValue(); 
    369      CTimer::get("XIOS").suspend(); 
    370   } 
    371    
    372    
    373    
     372 
     373  bool cxios_is_defined_file_sync_freq(file_Ptr file_hdl) 
     374  { 
     375     CTimer::get("XIOS").resume(); 
     376     bool isDefined = file_hdl->sync_freq.hasInheritedValue(); 
     377     CTimer::get("XIOS").suspend(); 
     378     return isDefined; 
     379  } 
     380 
     381 
    374382  void cxios_set_file_type(file_Ptr file_hdl, const char * type, int type_size) 
    375383  { 
    376384    std::string type_str; 
    377     if(!cstr2string(type, type_size, type_str)) return; 
    378      CTimer::get("XIOS").resume(); 
     385    if (!cstr2string(type, type_size, type_str)) return; 
     386    CTimer::get("XIOS").resume(); 
    379387    file_hdl->type.fromString(type_str); 
    380      CTimer::get("XIOS").suspend(); 
    381   } 
    382    
     388    CTimer::get("XIOS").suspend(); 
     389  } 
     390 
    383391  void cxios_get_file_type(file_Ptr file_hdl, char * type, int type_size) 
    384392  { 
    385      CTimer::get("XIOS").resume(); 
    386     if(!string_copy(file_hdl->type.getInheritedStringValue(),type , type_size)) 
    387       ERROR("void cxios_get_file_type(file_Ptr file_hdl, char * type, int type_size)", <<"Input string is to short"); 
    388      CTimer::get("XIOS").suspend(); 
    389   } 
    390    
    391   bool cxios_is_defined_file_type(file_Ptr file_hdl ) 
    392   { 
    393      CTimer::get("XIOS").resume(); 
    394     return file_hdl->type.hasInheritedValue(); 
    395      CTimer::get("XIOS").suspend(); 
    396   } 
    397    
    398    
    399    
    400    
     393    CTimer::get("XIOS").resume(); 
     394    if (!string_copy(file_hdl->type.getInheritedStringValue(), type, type_size)) 
     395      ERROR("void cxios_get_file_type(file_Ptr file_hdl, char * type, int type_size)", << "Input string is too short"); 
     396    CTimer::get("XIOS").suspend(); 
     397  } 
     398 
     399  bool cxios_is_defined_file_type(file_Ptr file_hdl) 
     400  { 
     401     CTimer::get("XIOS").resume(); 
     402     bool isDefined = file_hdl->type.hasInheritedValue(); 
     403     CTimer::get("XIOS").suspend(); 
     404     return isDefined; 
     405  } 
    401406} 
Note: See TracChangeset for help on using the changeset viewer.