static enkf_fs_type * enkf_fs_alloc_empty( const char * mount_point , bool read_only) {
enkf_fs_type * fs = util_malloc(sizeof * fs );
UTIL_TYPE_ID_INIT( fs , ENKF_FS_TYPE_ID );
fs->time_map = time_map_alloc();
fs->cases_config = cases_config_alloc();
fs->state_map = state_map_alloc();
fs->misfit_ensemble = misfit_ensemble_alloc();
fs->index = NULL;
fs->eclipse_static = NULL;
fs->parameter = NULL;
fs->dynamic_forecast = NULL;
fs->dynamic_analyzed = NULL;
fs->read_only = read_only;
fs->mount_point = util_alloc_string_copy( mount_point );
fs->refcount = 0;
fs->lock_fd = 0;
if (mount_point == NULL)
util_abort("%s: fatal internal error: mount_point == NULL \n",__func__);
{
char ** path_tmp;
int path_len;
util_path_split( fs->mount_point , &path_len , &path_tmp);
fs->case_name = util_alloc_string_copy( path_tmp[path_len - 1]);
fs->root_path = util_alloc_joined_string( (const char **) path_tmp , path_len , UTIL_PATH_SEP_STRING);
fs->lock_file = util_alloc_filename( fs->mount_point , fs->case_name , "lock");
util_free_stringlist( path_tmp , path_len );
}
return fs;
}
const enkf_config_node_type * ensemble_config_user_get_node(const ensemble_config_type * config , const char * full_key, char ** index_key ) {
const enkf_config_node_type * node = NULL;
char ** key_list;
int keys;
int key_length = 1;
int offset;
*index_key = NULL;
util_split_string(full_key , USER_KEY_JOIN_STRING , &keys , &key_list);
while (node == NULL && key_length <= keys) {
char * current_key = util_alloc_joined_string( (const char **) key_list , key_length , USER_KEY_JOIN_STRING );
if (ensemble_config_has_key(config , current_key))
node = ensemble_config_get_node(config , current_key);
else
key_length++;
offset = strlen( current_key );
free( current_key );
}
if (node != NULL) {
if (offset < strlen( full_key ))
*index_key = util_alloc_string_copy(&full_key[offset+1]);
}
util_free_stringlist(key_list , keys);
return node;
}
/*
This function creates a string buffer from a file. Furthermore, if the strings in pad_keys are found in the buffer,
they are padded with a space before and after.
I.e., if the file contains
key=value
and "=" is in pad_keys, then the buffer will read
key = value
*/
static
char * __conf_util_fscanf_alloc_token_buffer(
const char * file,
const char * comment,
int num_pad_keys,
const char ** pad_keys)
{
char * buffer_wrk = basic_parser_fread_alloc_file_content( file , NULL /* quote_set */ , NULL /* delete_set */ , "--" /* Comment start*/ , "\n" /* Comment end */);
char ** padded_keys = util_calloc(num_pad_keys , sizeof * padded_keys);
for(int key_nr = 0; key_nr < num_pad_keys; key_nr++)
{
assert(pad_keys[key_nr] != NULL);
int key_len = strlen(pad_keys[key_nr]);
padded_keys[key_nr] = util_calloc((key_len + 3) , sizeof * padded_keys[key_nr]);
padded_keys[key_nr][0] = ' ';
for(int i=0; i<key_len; i++)
{
padded_keys[key_nr][1+i] = pad_keys[key_nr][i];
}
padded_keys[key_nr][key_len + 1] = ' ';
padded_keys[key_nr][key_len + 2] = '\0';
}
char * buffer = util_string_replacen_alloc(buffer_wrk, num_pad_keys,
pad_keys, (const char **) padded_keys);
free(buffer_wrk);
util_free_stringlist(padded_keys, num_pad_keys);
return buffer;
}
static void output_add_key( const ecl_sum_type * refcase , output_type * output , const char * qkey) {
int tokens;
double quantile;
char ** tmp;
char * sum_key;
util_split_string( qkey , SUMMARY_JOIN , &tokens , &tmp);
if (tokens == 1)
util_exit("Hmmm - the key:%s is malformed - must be of the form SUMMARY_KEY:QUANTILE.\n",qkey);
if (!util_sscanf_double( tmp[tokens - 1] , &quantile))
util_exit("Hmmmm - failed to interpret:%s as a quantile - must be a number (0,1).\n",tmp[tokens-1]);
if (quantile <= 0 || quantile >= 1.0)
util_exit("Invalid quantile value:%g - must be in interval (0,1)\n", quantile);
sum_key = util_alloc_joined_string( (const char **) tmp , tokens - 1 , SUMMARY_JOIN);
{
stringlist_type * matching_keys = stringlist_alloc_new();
int i;
ecl_sum_select_matching_general_var_list( refcase , sum_key , matching_keys );
for (i=0; i < stringlist_get_size( matching_keys ); i++)
vector_append_owned_ref( output->keys , quant_key_alloc( stringlist_iget( matching_keys , i ) , quantile) , quant_key_free__ );
if (stringlist_get_size( matching_keys ) == 0)
fprintf(stderr,"** Warning: No summary vectors matching:\'%s\' found?? \n", sum_key);
stringlist_free( matching_keys );
}
util_free_stringlist( tmp, tokens );
}
static bool util_addr2line_lookup__(const void * bt_addr , char ** func_name , char ** file_name , int * line_nr, bool subtract_base_adress) {
*func_name = NULL; // If dladdr() succeeds, but addr2line fails the func_name pointer will be set, but the function will return false anyway.
*file_name = NULL;
*line_nr = 0;
{
bool address_found = false;
Dl_info dl_info;
#if defined(__APPLE__)
return false;
#else
if (dladdr(bt_addr , &dl_info)) {
const char * executable = dl_info.dli_fname;
*func_name = util_alloc_string_copy( dl_info.dli_sname );
if (util_file_exists( executable )) {
char *stdout_file = util_alloc_tmp_file("/tmp" , "addr2line" , true);
/* 1: Run addr2line application */
{
char ** argv = util_calloc(3 , sizeof * argv );
argv[0] = util_alloc_string_copy("--functions");
argv[1] = util_alloc_sprintf("--exe=%s" , executable );
{
char * rel_address = (char *) bt_addr;
if (subtract_base_adress)
rel_address -= (size_t) dl_info.dli_fbase;
argv[2] = util_alloc_sprintf("%p" , (void *) rel_address);
}
util_spawn_blocking("addr2line", 3, (const char **) argv, stdout_file, NULL);
util_free_stringlist(argv , 3);
}
/* 2: Parse stdout output */
{
bool at_eof;
FILE * stream = util_fopen(stdout_file , "r");
char * tmp_fname = util_fscanf_alloc_line(stream , &at_eof);
if (strcmp(tmp_fname , UNDEFINED_FUNCTION) != 0) {
char * stdout_file_name = util_fscanf_alloc_line(stream , &at_eof);
char * line_string = NULL;
util_binary_split_string( stdout_file_name , ":" , false , file_name , &line_string);
if (line_string && util_sscanf_int( line_string , line_nr))
address_found = true;
free( stdout_file_name );
util_safe_free( line_string );
}
free( tmp_fname );
fclose(stream);
}
util_unlink_existing(stdout_file);
free( stdout_file );
}
}
return address_found;
#endif
}
}
void job_queue_node_free_data(job_queue_node_type * node) {
util_safe_free( node->job_name );
util_safe_free( node->exit_file );
util_safe_free( node->ok_file );
util_safe_free( node->run_cmd );
util_free_stringlist( node->argv , node->argc );
if (node->job_data != NULL)
util_abort("%s: internal error - driver spesific job data has not been freed - will leak.\n",__func__);
}
/** Will loose tagging .... */
int subst_list_add_from_string( subst_list_type * subst_list , const char * arg_string, bool append) {
int error_count = 0;
if (arg_string != NULL) {
char ** key_value_list;
int num_arg, iarg;
util_split_string(arg_string , "," , &num_arg , &key_value_list);
for (iarg = 0; iarg < num_arg; iarg++) {
if (strchr(key_value_list[iarg] , '=') == NULL)
//util_abort("%s: could not find \'=\' in argument string:%s \n",__func__ , key_value_list[iarg]);
/*
Could not find '=' in the argument string, this argument will
be ignored, and the error_count will be increased by one.
*/
error_count += 1;
else {
char * key , * value;
char * tmp = key_value_list[iarg];
int arg_length , value_length;
while (isspace(*tmp)) /* Skipping initial space */
tmp++;
arg_length = strcspn(tmp , " =");
key = util_alloc_substring_copy(tmp , 0 , arg_length);
tmp += arg_length;
while ((*tmp == ' ') || (*tmp == '='))
tmp++;
value_length = strcspn(tmp , " ");
value = util_alloc_substring_copy( tmp , 0 , value_length);
/* Setting the argument */
if (append)
subst_list_append_copy( subst_list , key , value , NULL);
else
subst_list_prepend_copy( subst_list , key , value , NULL);
free(key);
free(value);
tmp += value_length;
/* Accept only trailing space - any other character indicates a failed parsing. */
while (*tmp != '\0') {
if (!isspace(*tmp))
util_abort("%s: something wrong with:%s - spaces are not allowed in key or value part.\n",__func__ , key_value_list[iarg]);
tmp++;
}
}
}
util_free_stringlist(key_value_list , num_arg);
}
return error_count;
}
stringlist_type * stringlist_alloc_from_split( const char * input_string , const char * sep ) {
stringlist_type * slist = stringlist_alloc_new();
if (input_string != NULL) {
char ** items;
int num_items , i;
util_split_string( input_string , sep , &num_items , &items);
for ( i =0; i < num_items; i++)
stringlist_append_copy( slist , items[i] );
util_free_stringlist( items , num_items );
}
return slist;
}
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;
}
void sched_kw_gruptree_fprintf(const sched_kw_gruptree_type * kw, FILE * stream)
{
fprintf(stream, "GRUPTREE\n");
{
const int num_keys = hash_get_size(kw->gruptree_hash);
char ** child_list = hash_alloc_keylist(kw->gruptree_hash);
int i;
for (i = 0; i < num_keys; i++) {
const char * parent_name = hash_get_string(kw->gruptree_hash , child_list[i]);
fprintf(stream," '%s' '%s' /\n",child_list[i] , parent_name);
}
util_free_stringlist( child_list , num_keys );
}
fprintf(stream,"/\n\n");
};
static void load_stations(vector_type * grav_stations , const char * filename) {
printf("Loading from file:%s \n",filename);
{
int target_width;
FILE * stream = util_fopen(filename , "r");
bool at_eof = false;
/**
When reading the first line we determine how many columns the
file contains.
*/
{
char * first_line = util_fscanf_alloc_line( stream , &at_eof);
char ** token_list;
util_split_string( first_line , " \t" , &target_width , &token_list);
util_free_stringlist( token_list , target_width );
fseek( stream , 0 , SEEK_SET );
}
while(!(at_eof)) {
double x,y,d;
double obs_gdiff , std_gdiff;
char station_name[32];
int fscanf_return;
if (target_width == 4)
fscanf_return = fscanf(stream, "%s %lg %lg %lg", station_name , &x , &y , &d );
else
fscanf_return = fscanf(stream, "%s %lg %lg %lg %lg %lg", station_name , &x , &y , &d , &obs_gdiff , &std_gdiff);
if (fscanf_return == target_width) {
grav_station_type * g = grav_station_alloc_new(station_name , x , y , d);
if (target_width == 6)
grav_station_add_obs( g , obs_gdiff , std_gdiff );
vector_append_owned_ref(grav_stations, g, grav_station_free__);
} else
at_eof = true;
}
fclose(stream);
}
}
static void util_addr2line_lookup(const char * executable , const char * bt_symbol , char ** func_name , char ** file_line) {
char *tmp_file = util_alloc_tmp_file("/tmp" , "addr2line" , true);
char * adress;
{
int start_pos = 0;
int end_pos;
while ( bt_symbol[start_pos] != '[')
start_pos++;
end_pos = start_pos;
while ( bt_symbol[end_pos] != ']')
end_pos++;
adress = util_alloc_substring_copy( bt_symbol , start_pos + 1 , end_pos - start_pos - 1 );
}
{
char ** argv;
argv = util_calloc(3 , sizeof * argv );
argv[0] = util_alloc_string_copy("--functions");
argv[1] = util_alloc_sprintf("--exe=%s" , executable);
argv[2] = util_alloc_string_copy(adress);
util_fork_exec("addr2line" , 3 , (const char **) argv , true , NULL , NULL , NULL , tmp_file , NULL);
util_free_stringlist(argv , 3);
}
{
bool at_eof;
FILE * stream = util_fopen(tmp_file , "r");
*func_name = util_fscanf_alloc_line(stream , &at_eof);
*file_line = util_fscanf_alloc_line(stream , &at_eof);
fclose(stream);
}
util_unlink_existing(tmp_file);
free(adress);
free(tmp_file);
}
const char * util_update_path_var(const char * variable, const char * value, bool append) {
const char * current_value = getenv( variable );
if (current_value == NULL)
/* The (path) variable is not currently set. */
util_setenv( variable , value );
else {
bool update = true;
{
char ** path_list;
int num_path;
util_split_string( current_value , ":" , &num_path , &path_list);
if (append) {
int i;
for (i = 0; i < num_path; i++) {
if (util_string_equal( path_list[i] , value))
update = false; /* The environment variable already contains @value - no point in appending it at the end. */
}
} else {
if (util_string_equal( path_list[0] , value))
update = false; /* The environment variable already starts with @value. */
}
util_free_stringlist( path_list , num_path );
}
if (update) {
char * new_value;
if (append)
new_value = util_alloc_sprintf("%s:%s" , current_value , value);
else
new_value = util_alloc_sprintf("%s:%s" , value , current_value);
util_setenv( variable , new_value );
free( new_value );
}
}
return getenv( variable );
}
void hash_iter_free(hash_iter_type * iter) {
util_free_stringlist(iter->keylist, iter->num_keys);
free(iter);
}
void util_abort(const char * fmt , ...) {
pthread_mutex_lock( &__abort_mutex ); /* Abort before unlock() */
{
va_list ap;
va_start(ap , fmt);
printf("\n\n");
fprintf(stderr,"\n\n");
vfprintf(stderr , fmt , ap);
va_end(ap);
/*
The backtrace is based on calling the external program
addr2line; the call is based on util_fork_exec() which is
currently only available on POSIX.
*/
const bool include_backtrace = true;
if (include_backtrace) {
const int max_bt = 50;
char *executable;
void *array[max_bt];
char **strings;
char ** func_list;
char ** file_line_list;
int max_func_length = 0;
int size,i;
if (__abort_program_message != NULL) {
fprintf(stderr,"--------------------------------------------------------------------------------\n");
fprintf(stderr,"%s",__abort_program_message);
fprintf(stderr,"--------------------------------------------------------------------------------\n");
}
fprintf(stderr,"\n");
fprintf(stderr,"****************************************************************************\n");
fprintf(stderr,"** **\n");
fprintf(stderr,"** A fatal error occured, and we have to abort. **\n");
fprintf(stderr,"** **\n");
fprintf(stderr,"** We now *try* to provide a backtrace, which would be very useful **\n");
fprintf(stderr,"** when debugging. The process of making a (human readable) backtrace **\n");
fprintf(stderr,"** is quite complex, among other things it involves several calls to the **\n");
fprintf(stderr,"** external program addr2line. We have arrived here because the program **\n");
fprintf(stderr,"** state is already quite broken, so the backtrace might be (seriously) **\n");
fprintf(stderr,"** broken as well. **\n");
fprintf(stderr,"** **\n");
fprintf(stderr,"****************************************************************************\n");
size = backtrace(array , max_bt);
strings = backtrace_symbols(array , size);
executable = util_bt_alloc_current_executable(strings[0]);
if (executable != NULL) {
fprintf(stderr,"Current executable : %s \n",executable);
func_list = util_calloc(size , sizeof * func_list );
file_line_list = util_calloc(size , sizeof * file_line_list );
for (i=0; i < size; i++) {
util_addr2line_lookup(executable , strings[i] , &func_list[i] , &file_line_list[i]);
max_func_length = util_int_max(max_func_length , strlen(func_list[i]));
}
{
char string_fmt[64];
sprintf(string_fmt, " #%s02d %s-%ds(..) in %ss \n" , "%" , "%" , max_func_length , "%");
fprintf(stderr , "--------------------------------------------------------------------------------\n");
for (i=0; i < size; i++) {
int line_nr;
if (util_sscanf_int(file_line_list[i] , &line_nr))
fprintf(stderr, string_fmt , i , func_list[i], file_line_list[i]);
else
fprintf(stderr, string_fmt , i , func_list[i], file_line_list[i]);
}
fprintf(stderr , "--------------------------------------------------------------------------------\n");
util_free_stringlist(func_list , size);
util_free_stringlist(file_line_list , size);
}
} else
fprintf(stderr,"Could not determine executable file for:%s - no backtrace. \n",strings[0]);
free(strings);
util_safe_free(executable);
}
if (getenv("UTIL_ABORT") != NULL) {
fprintf(stderr , "Aborting ... \n");
abort();
} else {
fprintf(stderr , "Exiting ... \n");
exit(1);
}
// Would have preferred abort() here - but that comes in conflict with the SIGABRT signal.
}
pthread_mutex_unlock( &__abort_mutex );
}