ecl_rft_node_type * ecl_rft_node_alloc_new(const char * well_name, const char * data_type_string, const time_t recording_date, const double days){ ecl_rft_enum data_type = translate_from_sting_to_ecl_rft_enum(data_type_string); ecl_rft_node_type * rft_node = util_malloc(sizeof * rft_node ); UTIL_TYPE_ID_INIT( rft_node , ECL_RFT_NODE_ID ); rft_node->well_name = util_alloc_string_copy(well_name); rft_node->cells = vector_alloc_new(); rft_node->recording_date = recording_date; rft_node->days = days; rft_node->data_type = data_type; rft_node->sort_perm = NULL; rft_node->sort_perm_in_sync = false; return rft_node; }
void sched_kw_gruptree_alloc_child_parent_list(const sched_kw_gruptree_type * kw, char *** __children, char *** __parents, int * num_pairs) { *num_pairs = hash_get_size(kw->gruptree_hash); char ** children = hash_alloc_keylist(kw->gruptree_hash); char ** parents = util_malloc(*num_pairs * sizeof * parents); for(int child_nr = 0; child_nr < *num_pairs; child_nr++) { parents[child_nr] = util_alloc_string_copy(hash_get_string(kw->gruptree_hash, children[child_nr])); } *__children = children; *__parents = parents; }
obs_vector_type * obs_vector_alloc(obs_impl_type obs_type , const char * obs_key , enkf_config_node_type * config_node, int num_reports) { obs_vector_type * vector = util_malloc(sizeof * vector ); UTIL_TYPE_ID_INIT( vector , OBS_VECTOR_TYPE_ID); vector->freef = NULL; vector->measure = NULL; vector->get_obs = NULL; vector->user_get = NULL; vector->chi2 = NULL; vector->update_std_scale = NULL; vector->step_list = int_vector_alloc(0,0); switch (obs_type) { case(SUMMARY_OBS): vector->freef = summary_obs_free__; vector->measure = summary_obs_measure__; vector->get_obs = summary_obs_get_observations__; vector->user_get = summary_obs_user_get__; vector->chi2 = summary_obs_chi2__; vector->update_std_scale = summary_obs_update_std_scale__; break; case(BLOCK_OBS): vector->freef = block_obs_free__; vector->measure = block_obs_measure__; vector->get_obs = block_obs_get_observations__; vector->user_get = block_obs_user_get__; vector->chi2 = block_obs_chi2__; vector->update_std_scale = block_obs_update_std_scale__; break; case(GEN_OBS): vector->freef = gen_obs_free__; vector->measure = gen_obs_measure__; vector->get_obs = gen_obs_get_observations__; vector->user_get = gen_obs_user_get__; vector->chi2 = gen_obs_chi2__; vector->update_std_scale = gen_obs_update_std_scale__; break; default: util_abort("%s: internal error - obs_type:%d not recognized \n",__func__ , obs_type); } vector->obs_type = obs_type; vector->config_node = config_node; vector->obs_key = util_alloc_string_copy( obs_key ); vector->num_active = 0; vector->nodes = vector_alloc_new(); obs_vector_resize(vector , num_reports + 1); /* +1 here ?? Ohh - these +/- problems. */ return vector; }
char * ert_run_context_alloc_runpath( int iens , path_fmt_type * runpath_fmt , subst_list_type * subst_list , int iter) { char * runpath; { char * first_pass = path_fmt_alloc_path(runpath_fmt , false , iens, iter); /* 1: Replace first %d with iens, if a second %d replace with iter */ if (subst_list) runpath = subst_list_alloc_filtered_string( subst_list , first_pass ); /* 2: Filter out various magic strings like <CASE> and <CWD>. */ else runpath = util_alloc_string_copy( first_pass ); free( first_pass ); } return runpath; }
ensemble_config_type * ensemble_config_alloc( ) { ensemble_config_type * ensemble_config = util_malloc(sizeof * ensemble_config ); UTIL_TYPE_ID_INIT( ensemble_config , ENSEMBLE_CONFIG_TYPE_ID ); ensemble_config->config_nodes = hash_alloc(); ensemble_config->field_trans_table = field_trans_table_alloc(); ensemble_config->refcase = NULL; ensemble_config->gen_kw_format_string = util_alloc_string_copy( DEFAULT_GEN_KW_TAG_FORMAT ); ensemble_config->have_forward_init = false; ensemble_config->summary_key_matcher = summary_key_matcher_alloc(); pthread_mutex_init( &ensemble_config->mutex , NULL); return ensemble_config; }
void ensemble_load_from_glob( ensemble_type * ensemble , const char * pattern , thread_pool_type * tp) { glob_t pglob; int i; glob( pattern , GLOB_NOSORT , NULL , &pglob ); for (i=0; i < pglob.gl_pathc; i++) { arg_pack_type * arg_pack = arg_pack_alloc( ); arg_pack_append_ptr( arg_pack , ensemble ); arg_pack_append_owned_ptr( arg_pack , util_alloc_string_copy( pglob.gl_pathv[i] ) , free ); thread_pool_add_job( tp , ensemble_add_case__ , arg_pack ); } globfree( &pglob ); }
char * util_alloc_parent_path( const char * path) { int path_ncomp; char ** path_component_list; char * parent_path = NULL; if (path) { bool is_abs = util_is_abs_path( path ); char * work_path; if (strstr(path , "..")) { if (is_abs) work_path = util_alloc_realpath__( path ); else { char * abs_path = util_alloc_realpath__( path ); char * cwd = util_alloc_cwd(); work_path = util_alloc_rel_path( cwd , abs_path ); free( abs_path ); free( cwd ); } } else work_path = util_alloc_string_copy( path ); util_path_split( work_path , &path_ncomp , &path_component_list ); if (path_ncomp > 0) { int current_length = 4; int ip; parent_path = util_realloc( parent_path , current_length * sizeof * parent_path); parent_path[0] = '\0'; for (ip=0; ip < path_ncomp - 1; ip++) { const char * ipath = path_component_list[ip]; int min_length = strlen(parent_path) + strlen(ipath) + 1; if (min_length >= current_length) { current_length = 2 * min_length; parent_path = util_realloc( parent_path , current_length * sizeof * parent_path); } if (is_abs || (ip > 0)) strcat( parent_path , UTIL_PATH_SEP_STRING ); strcat( parent_path , ipath ); } } util_free_stringlist( path_component_list , path_ncomp ); free( work_path ); } return parent_path; }
static point_obs_type * point_obs_alloc( block_obs_source_type source_type , int i , int j , int k , int active_index , char * sum_key , double value , double std) { point_obs_type * point_obs = util_malloc( sizeof * point_obs ); UTIL_TYPE_ID_INIT( point_obs , POINT_OBS_TYPE_ID ); point_obs->source_type = source_type; point_obs->i = i; point_obs->j = j; point_obs->k = k; point_obs->active_index = active_index; point_obs->value = value; point_obs->std = std; point_obs->sum_key = util_alloc_string_copy( sum_key ); return point_obs; }
static plplot_state_type * plplot_state_alloc( const void * init_arg ) { plplot_state_type * state = util_malloc( sizeof * state ); state->stream = 0; { const arg_pack_type * arg_pack = arg_pack_safe_cast_const( init_arg ); state->filename = util_alloc_string_copy( arg_pack_iget_const_ptr( arg_pack , 0) ); state->device = util_alloc_string_copy( arg_pack_iget_const_ptr( arg_pack , 1) ); plsstrm(state->stream); plsdev(state->device); /* Can this be NULL?? */ if (strcmp(state->device , "xwin") != 0) plsfnam(state->filename); } state->logx = false; state->logy = false; state->plbox_xopt = util_alloc_string_copy( PLOT_DEFAULT_PLBOX_XOPT ); state->plbox_yopt = util_alloc_string_copy( PLOT_DEFAULT_PLBOX_YOPT ); /** This color initialization must be here - do not really understand what for. */ plscol0(WHITE, 255, 255, 255); plscol0(BLACK, 0, 0, 0); plfontld(0); //plinit(); return state; }
config_schema_item_type * config_schema_item_alloc(const char * kw , bool required) { config_schema_item_type * item = util_malloc(sizeof * item ); UTIL_TYPE_ID_INIT( item , CONFIG_SCHEMA_ITEM_ID); item->kw = util_alloc_string_copy(kw); item->required_set = required; item->deprecated = false; item->deprecate_msg = NULL; item->required_children = NULL; item->required_children_value = NULL; item->expand_envvar = true; /* Default is to expand $VAR expressions; can be turned off with config_schema_item_set_envvar_expansion( item , false ); */ item->validate = validate_alloc(); return item; }
void enkf_tui_fs_copy_ensemble_of_parameters(void * arg) { int prompt_len = 35; char * source_case; int last_report; int report_step_from; char * report_step_from_as_char; int report_step_to; state_enum state_from; state_enum state_to; enkf_main_type * enkf_main = enkf_main_safe_cast( arg ); source_case = util_alloc_string_copy(enkf_main_get_current_fs( enkf_main )); last_report = enkf_main_get_history_length( enkf_main ); report_step_from_as_char = util_scanf_int_with_limits_return_char("Source report step",prompt_len , 0 , last_report); if(strlen(report_step_from_as_char) !=0){ util_sscanf_int(report_step_from_as_char , &report_step_from); state_from = enkf_tui_util_scanf_state("Source analyzed/forecast [a|f]" , prompt_len , false); if(state_from != UNDEFINED){ util_printf_prompt("Target case" , prompt_len , '=' , "=> "); char target_case[256]; if ( fgets(target_case, prompt_len, stdin) ) { char *newline = strchr(target_case, '\n'); if (newline) *newline = 0; } if (strlen(target_case)) { char * report_step_to_as_char = util_scanf_int_with_limits_return_char("Target report step",prompt_len , 0 , last_report); if(strlen(report_step_to_as_char) !=0){ util_sscanf_int(report_step_to_as_char , &report_step_to); state_to = enkf_tui_util_scanf_state("Target analyzed/forecast [a|f]" , prompt_len , false); if(state_to != UNDEFINED){ enkf_tui_fs_copy_ensemble__(enkf_main, source_case, target_case, report_step_from, state_from, report_step_to, state_to, true); } } free(report_step_to_as_char); } } } free(source_case); free(report_step_from_as_char); }
menu_item_type * menu_add_item(menu_type * menu , const char * label , const char * key_set , menu_func_type * func, void * arg , arg_free_ftype * free_arg) { if (__string_contains(menu->complete_key_set , key_set)) util_abort("%s:fatal error when building menu - key(s) in:%s already in use \n",__func__ , key_set); { menu_item_type * item = menu_item_alloc_empty(); item->key_set = util_alloc_string_copy(key_set); item->func = func; item->arg = arg; item->separator = false; item->helptext = false; item->free_arg = free_arg; menu_append_item__(menu , item); menu_item_set_label(item , label); menu->complete_key_set = util_strcat_realloc(menu->complete_key_set , key_set); return item; } }
static ecl_sum_type * ecl_sum_alloc__( const char * input_arg , const char * key_join_string) { ecl_sum_type * ecl_sum = util_malloc( sizeof * ecl_sum ); UTIL_TYPE_ID_INIT( ecl_sum , ECL_SUM_ID ); ecl_sum->ecl_case = NULL; ecl_sum->path = NULL; ecl_sum->base = NULL; ecl_sum->ext = NULL; ecl_sum->abs_path = NULL; ecl_sum_set_case( ecl_sum , input_arg ); ecl_sum->key_join_string = util_alloc_string_copy( key_join_string ); ecl_sum->smspec = NULL; ecl_sum->data = NULL; return ecl_sum; }
static void enkf_tui_ranking_create_obs( void * arg ) { enkf_main_type * enkf_main = enkf_main_safe_cast( arg ); enkf_obs_type * enkf_obs = enkf_main_get_obs( enkf_main ); enkf_fs_type * fs = enkf_main_get_fs( enkf_main ); misfit_ensemble_type * misfit_ensemble = enkf_fs_get_misfit_ensemble( fs ); if (!misfit_ensemble_initialized( misfit_ensemble )) { fprintf(stderr,"Sorry: must initialzie the misfit table first \n"); return; } else { ranking_table_type * ranking_table = enkf_main_get_ranking_table( enkf_main ); const int history_length = enkf_main_get_history_length( enkf_main ); const int prompt_len = 50; const char * prompt1 = "Observations to use for ranking"; const char * prompt2 = "Name to store ranking under"; const char * store_prompt = "Name of file to store ranking"; int step1,step2; stringlist_type * ranking_keys; char * obs_keys_input; char * ranking_key; char * ranking_file; util_printf_prompt(prompt1 , prompt_len , '=' , "=> "); obs_keys_input = util_alloc_stdin_line(); ranking_keys = enkf_obs_alloc_matching_keylist( enkf_obs , obs_keys_input ); enkf_tui_util_scanf_report_steps(history_length , prompt_len , &step1 , &step2); util_printf_prompt(prompt2 , prompt_len , '=' , "=> "); ranking_key = util_alloc_stdin_line(); if (ranking_key == NULL) ranking_key = util_alloc_string_copy( MISFIT_DEFAULT_RANKING_KEY ); util_printf_prompt(store_prompt , prompt_len , '=' , "=> "); ranking_file = util_alloc_stdin_line(); if (stringlist_get_size( ranking_keys ) > 0) { ranking_table_add_misfit_ranking( ranking_table , misfit_ensemble , ranking_keys , step1 , step2 , ranking_key ); ranking_table_display_ranking( ranking_table , ranking_key); } else fprintf(stderr,"The input string : \"%s\" did not resolve to any valid observation keys \n", obs_keys_input); free( obs_keys_input ); stringlist_free( ranking_keys ); free( ranking_key ); util_safe_free( ranking_file ); } }
void create_test_area(const char * test_name , bool store) { char * pre_cwd = util_alloc_cwd(); test_work_area_type * work_area = test_work_area_alloc( test_name , store); char * work_path = util_alloc_string_copy( test_work_area_get_cwd( work_area )); test_assert_true( util_is_directory( work_path )); test_work_area_free( work_area ); test_assert_bool_equal( store , util_entry_exists( work_path )); { char * post_cwd = util_alloc_cwd(); test_assert_string_equal( pre_cwd , post_cwd ); free( post_cwd ); } free( pre_cwd ); free( work_path ); }
plot_type * plot_alloc(const char * __driver_type , void * init_arg , bool logx , bool logy) { plot_type * plot = util_malloc(sizeof *plot ); { /* Loading the driver: */ char * driver_type = util_alloc_string_copy( __driver_type ); util_strupr( driver_type ); if (util_string_equal( driver_type , "PLPLOT")) plot->driver = plplot_driver_alloc(init_arg); else if (util_string_equal( driver_type , "TEXT")) plot->driver = text_driver_alloc(init_arg); else util_abort("%s: plot driver:%s not implemented ... \n",__func__ , __driver_type); plot_driver_assert( plot->driver ); free( driver_type ); } /* Initializing plot data which is common to all drivers. */ plot->is_histogram = false; plot->dataset = vector_alloc_new(); plot->dataset_hash = hash_alloc(); plot->range = plot_range_alloc(); plot->timefmt = NULL; plot->xlabel = NULL; plot->ylabel = NULL; plot->title = NULL; /* These functions only manipulate the internal plot_state variables, and do not call the driver functions. */ plot_set_window_size(plot , PLOT_DEFAULT_WIDTH , PLOT_DEFAULT_HEIGHT); plot_set_box_color(plot , PLOT_DEFAULT_BOX_COLOR); plot_set_label_color(plot , PLOT_DEFAULT_LABEL_COLOR); plot_set_label_fontsize(plot , 1.0); plot_set_axis_fontsize(plot , 1.0); plot_set_labels(plot , "" , "" , ""); /* Initializeing with empty labels. */ plot_set_log( plot , logx , logy); /* Default - no log on the axis. */ return plot; }
local_ministep_type * local_ministep_alloc(const char * name, analysis_module_type* analysis_module) { local_ministep_type * ministep = util_malloc( sizeof * ministep ); ministep->name = util_alloc_string_copy( name ); char* obsdata_name = "OBSDATA_"; char* result = malloc(strlen(obsdata_name)+strlen(name)+1); strcpy(result, obsdata_name); strcat(result, name); ministep->observations = local_obsdata_alloc(result); ministep->datasets = hash_alloc(); ministep->analysis_module = analysis_module; UTIL_TYPE_ID_INIT( ministep , LOCAL_MINISTEP_TYPE_ID); return ministep; }
member_config_type * member_config_alloc(int iens , const char * casename , bool pre_clear_runpath , keep_runpath_type keep_runpath , const ecl_config_type * ecl_config , const ensemble_config_type * ensemble_config, enkf_fs_type * fs) { member_config_type * member_config = util_malloc( sizeof * member_config ); member_config->casename = util_alloc_string_copy( casename ); member_config->iens = iens; /* Can only be changed in the allocater. */ member_config->eclbase = NULL; member_config->jobname = NULL; member_config->pre_clear_runpath = pre_clear_runpath; member_config_set_keep_runpath(member_config , keep_runpath); return member_config; }
static ecl_grav_survey_type * ecl_grav_survey_alloc_empty(const ecl_grav_type * ecl_grav , const char * name , grav_calc_type calc_type) { ecl_grav_survey_type * survey = util_malloc( sizeof * survey ); UTIL_TYPE_ID_INIT( survey , ECL_GRAV_SURVEY_ID ); survey->grid_cache = ecl_grav->grid_cache; survey->aquifer_cell = ecl_grav->aquifer_cell; survey->name = util_alloc_string_copy( name ); survey->phase_list = vector_alloc_new(); survey->phase_map = hash_alloc(); if (calc_type & GRAV_CALC_USE_PORV) survey->porv = util_calloc( ecl_grid_cache_get_size( ecl_grav->grid_cache ) , sizeof * survey->porv ); else survey->porv = NULL; return survey; }
data_ranking_type * data_ranking_alloc( bool sort_increasing , int ens_size , const char * user_key , const char * key_index , enkf_fs_type * fs , const enkf_config_node_type * config_node , int step , state_enum state) { data_ranking_type * ranking = util_malloc( sizeof * ranking ); UTIL_TYPE_ID_INIT( ranking , DATA_RANKING_TYPE_ID ); ranking->ens_size = ens_size; ranking->sort_increasing = sort_increasing; if (ranking->sort_increasing) ranking->data_ensemble = double_vector_alloc( ens_size , INFINITY); // To ensure it comes last when sorting else ranking->data_ensemble = double_vector_alloc( ens_size , -INFINITY); // To ensure it comes last when sorting ranking->valid = bool_vector_alloc( ens_size , false ); ranking->sort_permutation = NULL; ranking->user_key = util_alloc_string_copy( user_key ); data_ranking_init( ranking , fs , config_node , key_index , step , state ); return ranking; }
static void enkf_tui_ranking_display( void * arg ) { enkf_main_type * enkf_main = enkf_main_safe_cast( arg ); ranking_table_type * ranking_table = enkf_main_get_ranking_table( enkf_main ); const int prompt_len = 50; const char * prompt1 = "Ranking to display"; char * ranking_key; util_printf_prompt(prompt1 , prompt_len , '=' , "=> "); ranking_key = util_alloc_stdin_line(); if (ranking_key == NULL) ranking_key = util_alloc_string_copy( MISFIT_DEFAULT_RANKING_KEY); if (ranking_table_has_ranking( ranking_table , ranking_key)) ranking_table_display_ranking( ranking_table , ranking_key); else fprintf(stderr,"Sorry: could not find ranking key: %s \n", ranking_key ); free( ranking_key ); }
char * util_alloc_PATH_executable(const char * executable) { if (util_is_abs_path(executable)) { if (util_is_executable(executable)) return util_alloc_string_copy(executable); else return NULL; } else if (strncmp(executable , "./" , 2) == 0) { char * cwd = util_alloc_cwd(); char * path = util_alloc_filename(cwd , &executable[2] , NULL); /* The program has been invoked as ./xxxx */ if (!(util_is_file(path) && util_is_executable( path ))) { free( path ); path = NULL; } free( cwd ); return path; } else { char * full_path = NULL; char ** path_list = util_alloc_PATH_list(); int ipath = 0; while (true) { if (path_list[ipath] != NULL) { char * current_attempt = util_alloc_filename(path_list[ipath] , executable , NULL); if ( util_is_file( current_attempt ) && util_is_executable( current_attempt )) { full_path = current_attempt; break; } else { free(current_attempt); ipath++; } } else break; } util_free_NULL_terminated_stringlist(path_list); return full_path; } }
/** 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 ); }
hash_type * hash_alloc_from_options(const stringlist_type * options) { int num_options = stringlist_get_size( options ); hash_type * opt_hash = hash_alloc(); int iopt; for (iopt = 0; iopt < num_options; iopt++) { char * option; char * value; util_binary_split_string( stringlist_iget(options , iopt) , ":" , true , &option , &value); if ((option != NULL) && (value != NULL)) hash_insert_hash_owned_ref( opt_hash , option , util_alloc_string_copy(value) , free); // Warning: could not interpret string as KEY:VALUE - ignored util_safe_free(option); util_safe_free(value); } return opt_hash; }
static int ecl_util_get_month_nr__(const char * _month_name) { int month_nr = -1; char * month_name = util_alloc_string_copy(_month_name); util_strupr(month_name); if (strncmp(month_name , "JAN" , 3) == 0) month_nr = 1; else if (strncmp(month_name , "FEB" , 3) == 0) month_nr = 2; else if (strncmp(month_name , "MAR" , 3) == 0) month_nr = 3; else if (strncmp(month_name , "APR" , 3) == 0) month_nr = 4; else if (strncmp(month_name , "MAI" , 3) == 0) month_nr = 5; else if (strncmp(month_name , "MAY" , 3) == 0) month_nr = 5; else if (strncmp(month_name , "JUN" , 3) == 0) month_nr = 6; else if (strncmp(month_name , "JUL" , 3) == 0) month_nr = 7; else if (strncmp(month_name , "JLY" , 3) == 0) /* ECLIPSE ambigus on July. */ month_nr = 7; else if (strncmp(month_name , "AUG" , 3) == 0) month_nr = 8; else if (strncmp(month_name , "SEP" , 3) == 0) month_nr = 9; else if (strncmp(month_name , "OCT" , 3) == 0) month_nr = 10; else if (strncmp(month_name , "OKT" , 3) == 0) month_nr = 10; else if (strncmp(month_name , "NOV" , 3) == 0) month_nr = 11; else if (strncmp(month_name , "DEC" , 3) == 0) month_nr = 12; else if (strncmp(month_name , "DES" , 3) == 0) month_nr = 12; free(month_name); return month_nr; }
/** The input vectors i,j,k should contain offset zero values. */ block_obs_type * block_obs_alloc(const char * obs_key, block_obs_source_type source_type , const stringlist_type * summary_keys , const void * data_config , const ecl_grid_type * grid , int size, const int * i, const int * j, const int * k, const double * obs_value, const double * obs_std) { block_obs_validate_ijk( grid , size , i,j,k); { block_obs_type * block_obs = util_malloc(sizeof * block_obs); char * sum_kw = NULL; UTIL_TYPE_ID_INIT( block_obs , BLOCK_OBS_TYPE_ID ); block_obs->obs_key = util_alloc_string_copy(obs_key); block_obs->data_config = data_config; block_obs->source_type = source_type; block_obs->size = 0; block_obs->point_list = NULL; block_obs->grid = grid; block_obs_resize( block_obs , size ); { for (int l=0; l < size; l++) { int active_index = ecl_grid_get_active_index3( block_obs->grid , i[l],j[l],k[l]); char * sum_key = NULL; if (source_type == SOURCE_SUMMARY) sum_key = stringlist_iget( summary_keys , l ); block_obs->point_list[l] = point_obs_alloc(source_type , i[l] , j[l] , k[l] , active_index , sum_key , obs_value[l] , obs_std[l]); } } return block_obs; } }
hash_type * config_content_item_alloc_hash(const config_content_item_type * item , bool copy) { hash_type * hash = hash_alloc(); if (item != NULL) { int inode; for (inode = 0; inode < vector_get_size( item->nodes ); inode++) { const config_content_node_type * node = config_content_item_iget_node(item , inode); const stringlist_type * src_list = config_content_node_get_stringlist( node ); const char * key = stringlist_iget(src_list , 0); const char * value = stringlist_iget(src_list , 1); if (copy) { hash_insert_hash_owned_ref(hash , key , util_alloc_string_copy(value) , free); } else hash_insert_ref(hash , key , value ); } } return hash; }
static char * util_bt_alloc_current_executable(const char * bt_symbol) { if (__current_executable != NULL) return util_alloc_string_copy(__current_executable ); else { if (bt_symbol != NULL) { int paren_pos = 0; char * path; while (bt_symbol[paren_pos] != '(' && bt_symbol[paren_pos] != ' ') paren_pos++; path = util_alloc_substring_copy(bt_symbol , 0 , paren_pos); if (util_is_abs_path(path)) return path; else { char * full_path = util_alloc_PATH_executable( path ); free(path); return full_path; } } else return NULL; } }
well_state_type * well_state_alloc(const char * well_name , int global_well_nr , bool open, well_type_enum type , int report_nr, time_t valid_from) { well_state_type * well_state = util_malloc( sizeof * well_state ); UTIL_TYPE_ID_INIT( well_state , WELL_STATE_TYPE_ID ); well_state->index_wellhead = vector_alloc_new(); well_state->name_wellhead = hash_alloc(); well_state->name = util_alloc_string_copy( well_name ); well_state->valid_from_time = valid_from; well_state->valid_from_report = report_nr; well_state->open = open; well_state->type = type; well_state->global_well_nr = global_well_nr; well_state->connections = hash_alloc(); well_state->segments = well_segment_collection_alloc(); well_state->branches = well_branch_collection_alloc(); well_state->is_MSW_well = false; /* See documentation of the 'IWEL_UNDOCUMENTED_ZERO' in well_const.h */ if ((type == UNDOCUMENTED_ZERO) && open) util_abort("%s: Invalid type value for open wells.\n",__func__ ); return well_state; }
static output_type * output_alloc( const char * file , const char * format_string) { output_type * output = util_malloc( sizeof * output ); output->keys = vector_alloc_new(); output->file = util_alloc_string_copy( file ); { format_type format; if ( util_string_equal(format_string , S3GRAPH_STRING)) format = S3GRAPH; else if ( util_string_equal( format_string , HEADER_STRING)) format = HEADER; else if ( util_string_equal( format_string , PLAIN_STRING) ) format = PLAIN; else { format = PLAIN; /* Compiler shut up. */ util_abort("%s: unrecognized format string:%s \n",__func__ , format_string); } output->format = format; } return output; }