自学教程：C++ util_realloc_string_copy函数代码示例

static void field_config_set_init_transform( field_config_type * config , const char * __init_transform_name ) {    const char * init_transform_name = NULL;    if (field_trans_table_has_key( config->trans_table , __init_transform_name))        init_transform_name = __init_transform_name;    config->init_transform_name = util_realloc_string_copy( config->init_transform_name , init_transform_name );    if (init_transform_name != NULL)        config->init_transform = field_trans_table_lookup( config->trans_table , init_transform_name);    else        config->init_transform = NULL;}

void ensemble_config_set_gen_kw_format( ensemble_config_type * ensemble_config , const char * gen_kw_format_string) {  if (!util_string_equal( gen_kw_format_string , ensemble_config->gen_kw_format_string)) {    stringlist_type * gen_kw_keys = ensemble_config_alloc_keylist_from_impl_type( ensemble_config , GEN_KW );    int i;    ensemble_config->gen_kw_format_string = util_realloc_string_copy( ensemble_config->gen_kw_format_string , gen_kw_format_string );    for (i=0; i < stringlist_get_size( gen_kw_keys ); i++) {      enkf_config_node_type * config_node = ensemble_config_get_node( ensemble_config , stringlist_iget( gen_kw_keys , i ));      gen_kw_config_update_tag_format( enkf_config_node_get_ref( config_node ) , gen_kw_format_string );    }    stringlist_free( gen_kw_keys );  }}

bool model_config_select_runpath( model_config_type * model_config , const char * path_key) {  if (hash_has_key( model_config->runpath_map , path_key )) {    model_config->current_runpath = hash_get( model_config->runpath_map , path_key );    model_config->current_path_key = util_realloc_string_copy( model_config->current_path_key , path_key);    return true;  } else {    if (model_config->current_runpath != NULL)  // OK - we already have a valid selection - stick to that and return False.      return false;    else {      util_abort("%s: path_key:%s does not exist - and currently no valid runpath selected /n",__func__ , path_key);      return false;    }  }}

static void field_config_set_output_transform( field_config_type * config , const char * __output_transform_name ) {    const char * output_transform_name = NULL;    if (field_trans_table_has_key( config->trans_table , __output_transform_name))        output_transform_name = __output_transform_name;    else if (__output_transform_name) {        fprintf(stderr , "Sorry: the field transformation function:%s is not recognized /n/n",__output_transform_name);        field_trans_table_fprintf(config->trans_table , stderr);        util_exit("Exiting ... /n");    }    config->output_transform_name = util_realloc_string_copy( config->output_transform_name , output_transform_name );    if (output_transform_name != NULL)        config->output_transform = field_trans_table_lookup( config->trans_table , output_transform_name);    else        config->output_transform = NULL;}

void enkf_config_node_update_min_std( enkf_config_node_type * config_node , const char * min_std_file ) {  if (!util_string_equal( config_node->min_std_file , min_std_file )) {    /* The current min_std_file and the new input are different, and       the min_std node must be cleared. */    if (config_node->min_std != NULL) {      enkf_node_free( config_node->min_std );      config_node->min_std = NULL;      free( config_node->min_std_file );    }  }  config_node->min_std_file = util_realloc_string_copy( config_node->min_std_file , min_std_file );  if (config_node->min_std_file != NULL) {    config_node->min_std = enkf_node_alloc( config_node );    enkf_node_fload( config_node->min_std , min_std_file );  }}

void ecl_config_set_data_file( ecl_config_type * ecl_config , const char * data_file) {  ecl_config->data_file = util_realloc_string_copy( ecl_config->data_file , data_file );  {    FILE * stream        = util_fopen( ecl_config->data_file , "r");    parser_type * parser = parser_alloc(NULL , NULL , NULL , NULL , "--" , "/n" );    char * init_tag      = enkf_util_alloc_tagged_string( "INIT" );        ecl_config->can_restart = parser_fseek_string( parser , stream , init_tag , false , true );         free( init_tag );    parser_free( parser );    fclose( stream );  }  ecl_config->start_date = ecl_util_get_start_date( ecl_config->data_file );  ecl_config->num_cpu    = ecl_util_get_num_cpu( ecl_config->data_file );}

/**   input_value can be NULL. */static void subst_list_string_set_value(subst_list_string_type * node, const char * input_value , const char * doc_string , subst_insert_type insert_mode) {  subst_list_string_free_content( node );  {    char * value;    if (insert_mode == SUBST_DEEP_COPY)      value = util_alloc_string_copy(input_value);    else      value = (char *) input_value;        if (insert_mode == SUBST_SHARED_REF)      node->value_owner = false;    else      node->value_owner = true;        node->value = value;  }    if (doc_string != NULL)    node->doc_string = util_realloc_string_copy( node->doc_string , doc_string );}

void gen_kw_config_set_parameter_file( gen_kw_config_type * config , const char * parameter_file ) {  config->parameter_file = util_realloc_string_copy( config->parameter_file , parameter_file );  vector_clear( config->parameters );  if (parameter_file != NULL) {    FILE * stream = util_fopen(parameter_file , "r");        while (true) {      char parameter_name[256];      int  fscanf_return;            fscanf_return = fscanf(stream , "%s" , parameter_name);      if (fscanf_return == 1) {        gen_kw_parameter_type * parameter  = gen_kw_parameter_alloc( parameter_name , config->tag_fmt);        trans_func_type       * trans_func = trans_func_fscanf_alloc( stream );        gen_kw_parameter_set_trans_func( parameter , trans_func );        vector_append_owned_ref( config->parameters , parameter , gen_kw_parameter_free__ );      } else         break; /* OK - we are ate EOF. */    }         fclose( stream );  }}

static void __print_helptext(char * label, int l) {    bool end_reached = false;    char * label_copy = util_alloc_string_copy( label );    char * first_part = "Dummy3";    char * second_part = "Dummy4";    while(!end_reached) {        int i;        if(strlen(label_copy) > l) {            util_binary_split_string_from_max_length(label_copy , " ", l , &first_part , &second_part);            printf("|    %s",first_part);            for (i=strlen(first_part); i < l; i++)                fputc(' ' , stdout);            printf("    |/n");            label_copy = util_realloc_string_copy(label_copy, second_part);        }        else {            printf("|    %s",label_copy);            for (i=strlen(label_copy); i < l; i++)                fputc(' ' , stdout);            printf("    |/n");            end_reached = true;        }    }}

void rml_enkf_log_set_log_file( rml_enkf_log_type * data , const char * log_file ) {  data->log_file = util_realloc_string_copy( data->log_file , log_file );}

void runpath_list_set_line_fmt( runpath_list_type * list , const char * line_fmt ) {  list->line_fmt = util_realloc_string_copy( list->line_fmt , line_fmt );}

void parser_set_comment_end( parser_type * parser , const char * comment_end ) {  __verify_string_length( comment_end );  parser->comment_end = util_realloc_string_copy( parser->comment_end , comment_end );}

void hook_manager_set_path( hook_manager_type * hook_manager , const char * path) {  hook_manager->path = util_realloc_string_copy( hook_manager->path , path );}

void plot_config_set_image_type(plot_config_type * plot_config , const char * image_type) {  plot_config->image_type = util_realloc_string_copy(plot_config->image_type , image_type);}

void matrix_set_name( matrix_type * matrix , const char * name) {  matrix->name = util_realloc_string_copy( matrix->name , name );}

void util_abort_test_set_intercept_function(const char * function) {  intercept_function = util_realloc_string_copy( intercept_function , function );}

void site_config_set_default_browser( site_config_type * site_config , const char * default_browser ) {  site_config->default_browser = util_realloc_string_copy( site_config->default_browser , default_browser );}

void site_config_set_lsf_request( site_config_type * site_config , const char * lsf_request) {  queue_driver_type * lsf_driver = site_config_get_queue_driver( site_config , LSF_DRIVER_NAME);  queue_driver_set_option( lsf_driver, LSF_RESOURCE , lsf_request );  if (!site_config->user_mode)     site_config->lsf_request_site = util_realloc_string_copy( site_config->lsf_request_site , lsf_request);}

void ecl_config_set_schedule_prediction_file( ecl_config_type * ecl_config , const char * schedule_prediction_file ) {  ecl_config->schedule_prediction_file = util_realloc_string_copy( ecl_config->schedule_prediction_file , schedule_prediction_file );}

void ecl_config_set_init_section( ecl_config_type * ecl_config , const char * input_init_section ) {  /* The semantic regarding INIT_SECTION is as follows:         1. If the INIT_SECTION points to an existing file - the          ecl_config->input_init_section is set to the absolute path of          this file.       2. If the INIT_SECTION points to a not existing file:          a. We assert that INIT_SECTION points to a pure filename,             i.e. /some/path/which/does/not/exist is NOT accepted. In             the case the input argument contain a path a error message             will be printed on stderr and the ->init_section will not             be set.          b. The ecl_config->input_init_section is set to point to this             file.          c. WE TRUST THE USER TO SUPPLY CONTENT (THROUGH SOME FUNKY             FORWARD MODEL) IN THE RUNPATH. This can unfortunately not             be checked/verified before the ECLIPSE simulation fails.     The INIT_SECTION keyword and <INIT> in the datafile (checked with     ecl_config->can_restart) interplay as follows:      CASE   |   INIT_SECTION  |  <INIT>    | OK ?     ---------------------------------------------     0      |   Present       | Present    |  Yes      1      |   Not Present   | Present    |  No         2      |   Present       | Not present|  No     3      |   Not Present   | Not present|  Yes     ---------------------------------------------     Case 0: This is the most flexible case, which can do arbitrary        restart.     Case 1: In this case the datafile will contain a <INIT> tag, we        we do not have the info to replace that tag with for        initialisation, and ECLIPSE will fail. Strictly speaking this        case can actually restart, but that is not enough - we let        this case fail hard.     Case 2: We have some INIT_SECTION infor, but no tag in he        datafile to update. If the datafile has embedded        initialisation info this case will work for init; but it is        logically flawed, and not accepted. Currently only a warning.     Case 3: This case has just the right amount of information for        initialisation, but it is 'consistently unable' to restart.       */  if (ecl_config->can_restart) {  /* The <INIT> tag is set. */    ecl_config->input_init_section = util_realloc_string_copy( ecl_config->input_init_section , input_init_section );   /* input_init_section = path/to/init_section         */    if (util_file_exists( ecl_config->input_init_section )) {                                                           /* init_section       = $CWD/path/to/init_section */       util_safe_free( ecl_config->init_section );      ecl_config->init_section = util_alloc_realpath(input_init_section);    } else {      char * path;            util_alloc_file_components( ecl_config->input_init_section , &path , NULL , NULL );      if (path != NULL)         fprintf(stderr,"** Warning: %s: When INIT_SECTION:%s points to a non-existing file - you can not have any path components./n",__func__ , input_init_section);      else         ecl_config->init_section = util_alloc_string_copy(input_init_section);            util_safe_free( path );    }  } else    /*        The <INIT> tag is not set - we can not utilize the       input_init_section info, and we just ignore it.    */    fprintf(stderr,"** Warning: <INIT> tag was not found in datafile - can not utilize INIT_SECTION keyword - ignored./n");}

void runpath_list_set_export_file( runpath_list_type * list , const char * export_file ) {  list->export_file = util_realloc_string_copy( list->export_file , export_file );}

void site_config_set_manual_url( site_config_type * site_config , const char * manual_url ) {  site_config->manual_url = util_realloc_string_copy( site_config->manual_url , manual_url );}

void parser_set_quoters( parser_type * parser , const char * quoters ) {  __verify_string_length( quoters );  parser->quoters = util_realloc_string_copy( parser->quoters , quoters );}

void field_config_set_ecl_kw_name(field_config_type * config , const char * ecl_kw_name) {    config->ecl_kw_name = util_realloc_string_copy(config->ecl_kw_name , ecl_kw_name);}

void parser_set_specials( parser_type * parser , const char * specials ) {  __verify_string_length( specials );  parser->specials = util_realloc_string_copy( parser->specials , specials );}

void plot_config_set_path(plot_config_type * plot_config , const char * plot_path) {  plot_config->plot_path = util_realloc_string_copy(plot_config->plot_path , plot_path);  util_make_path( plot_path );}

void parser_set_delete_set( parser_type * parser , const char * delete_set ) {  __verify_string_length( delete_set );  parser->delete_set = util_realloc_string_copy( parser->delete_set , delete_set );}

void plot_config_set_driver(plot_config_type * plot_config , const char * plot_driver) {  plot_config->driver = util_realloc_string_copy(plot_config->driver , plot_driver);}

void parser_set_comment_start( parser_type * parser , const char * comment_start ) {  __verify_string_length( comment_start );  parser->comment_start = util_realloc_string_copy( parser->comment_start , comment_start );}