void test_read_erroneous_gen_kw_file() { const char * parameter_filename = "MULTFLT_with_errors.txt"; const char * tmpl_filename = "MULTFLT.tmpl"; { FILE * stream = util_fopen(parameter_filename, "w"); const char * data = util_alloc_sprintf("MULTFLT1 NORMAL 0\nMULTFLT2 RAW\nMULTFLT3 NORMAL 0"); util_fprintf_string(data, 30, true, stream); util_fclose(stream); FILE * tmpl_stream = util_fopen(tmpl_filename, "w"); const char * tmpl_data = util_alloc_sprintf("<MULTFLT1> <MULTFLT2> <MULTFLT3>\n"); util_fprintf_string(tmpl_data, 30, true, tmpl_stream); util_fclose(tmpl_stream); } gen_kw_config_type * gen_kw_config = gen_kw_config_alloc_empty("MULTFLT", "<%s>"); vector_type * arg = vector_alloc_new(); vector_append_ref( arg , gen_kw_config ); vector_append_ref(arg, parameter_filename); test_assert_util_abort("arg_pack_fscanf", read_erroneous_gen_kw_file, arg); vector_free(arg); gen_kw_config_free(gen_kw_config); }
void test_filter_file1() { subst_list_type * subst_list = subst_list_alloc( NULL ); test_work_area_type * work_area = test_work_area_alloc("subst_list/filter1"); { FILE * stream = util_fopen("template" , "w"); fprintf(stream , "<KEY1>\n<KEY2>\n<KEY3>\n<KEY4>\n"); fclose(stream); } subst_list_append_copy( subst_list , "<KEY1>" , "Value1" , NULL); subst_list_append_copy( subst_list , "<KEY2>" , "Value2" , NULL); subst_list_append_copy( subst_list , "<KEY3>" , "Value3" , NULL); subst_list_append_copy( subst_list , "<KEY4>" , "Value4" , NULL); subst_list_filter_file( subst_list , "template" , "target"); { FILE * stream = util_fopen("target" , "r"); char s1[128],s2[128],s3[128],s4[128]; test_assert_int_equal( 4 , fscanf( stream , "%s %s %s %s" , s1,s2,s3,s4)); fclose(stream); test_assert_string_equal( s1 , "Value1"); test_assert_string_equal( s2 , "Value2"); test_assert_string_equal( s3 , "Value3"); test_assert_string_equal( s4 , "Value4"); } test_work_area_free( work_area ); subst_list_free( subst_list ); }
void test_run_workflow(const char * config_file , const char * job_file) { ert_test_context_type * test_context = ert_test_context_alloc("INSTALL_WORKFLOW" , config_file , NULL ); test_assert_false( ert_test_context_run_worklow( test_context , "No-does.not.exist")); ert_test_context_install_workflow_job( test_context , "JOB" , job_file ); { FILE * stream1 = util_fopen( "WFLOW1", "w"); FILE * stream2 = util_fopen( "WFLOW2", "w"); stringlist_type * args = stringlist_alloc_new( ); ert_test_context_fwrite_workflow_job( stream1 , "JOB" , args); stringlist_append_ref( args , "NewCase"); ert_test_context_fwrite_workflow_job( stream2 , "JOB" , args); stringlist_free( args ); fclose( stream1 ); fclose( stream2 ); } test_assert_true( ert_test_context_install_workflow( test_context , "WFLOW1" , "WFLOW1")); test_assert_true( ert_test_context_install_workflow( test_context , "WFLOW2" , "WFLOW2")); test_assert_true( ert_test_context_run_worklow( test_context , "WFLOW2")); test_assert_false( ert_test_context_run_worklow( test_context , "WFLOW1")); ert_test_context_free( test_context ); }
static int mmap_simple (const char *path) { char fname[MAXSIZ_PATH]; sprintf (fname,"%s/file",path); FILE *f = util_fopen(fname,"w",Rmmap_simple); if (f != NULL){ short int buf[10000]; int i; for (i=0; (unsigned int) i<sizeof(buf)/sizeof(buf[0]); i++)buf[i] = i; if (fwrite (buf,1,sizeof(buf),f)!=sizeof(buf)){ Rmmap_simple.prterr ("Can't write %d bytes\n",sizeof(buf)); }else{ fclose (f); Rmmap_simple.verbose ("%d bytes were written to %s\n" ,sizeof(buf),fname); f = util_fopen(fname,"r",Rmmap_simple); int mmap_size = sizeof(buf) * 2; short int *ptm = (short int*)mmap(0,mmap_size ,PROT_READ,MAP_SHARED,fileno(f),0); if (ptm == (short int*)-1){ Rmmap_simple.prterr ("Can't mmap: errno = %d %s\n" ,errno,strerror(errno)); }else{ /* This test try to prove that mmaping beyong eof yields all 0s. It does not work, so I changed the target of the loop so it test only below eof. */ Rmmap_simple.verbose ("mmap returned %p\n",ptm); int nbelm_buf = sizeof(buf)/sizeof(buf[0]); //for (i=0; i<mmap_size/sizeof(buf[0]); i++){ for (i=0; i<nbelm_buf; i++){ Rmmap_simple.verbose ("%d ",i); fflush(stdout); if (i > nbelm_buf){ if (ptm[i] != 0){ Rmmap_simple.prterr("Error reading beyond eof at offset %d\n" ,i*sizeof(buf[0])); break; } }else if (ptm[i] != i){ Rmmap_simple.prterr("Error reading at offset %d\n" ,i*sizeof(buf[0])); break; } } if (munmap((char*)ptm,sizeof(buf))==-1){ Rmmap_simple.prterr ("Can't munmap\n"); } } } fclose (f); util_unlink(fname,Rmmap_simple,0); } return Rmmap_simple.getnberr(); }
/* Save play list to M3U format */ bool_t plist_save_m3u( plist_t *pl, char *filename ) { FILE *fd; int i; /* Try to create file */ fd = util_fopen(filename, "wt"); if (fd == NULL) return FALSE; /* Write list head */ fprintf(fd, "#EXTM3U\n"); for ( i = 0; i < pl->m_len; i ++ ) { song_t *s = pl->m_list[i]; fprintf(fd, "#EXTINF:%i", TIME_TO_SECONDS(s->m_len)); if (s->m_start_time >= 0) fprintf(fd, "-%i", TIME_TO_SECONDS(s->m_start_time)); fprintf(fd, ",%s\n%s\n", STR_TO_CPTR(s->m_title), song_get_name(s)); } /* Close file */ fclose(fd); return TRUE; } /* End of 'plist_save_m3u' function */
rng_type * rng_config_init_rng__(const rng_config_type * rng_config, rng_type * rng) { const char * seed_load = rng_config_get_seed_load_file( rng_config ); const char * seed_store = rng_config_get_seed_store_file( rng_config ); if (seed_load != NULL) { if (util_file_exists( seed_load)) { FILE * stream = util_fopen( seed_load , "r"); rng_fscanf_state( rng , stream ); fclose( stream ); } else { /* In the special case that seed_load == seed_store; we accept a seed_load argument pointing to a non-existant file. */ if (seed_store) { if (util_string_equal( seed_store , seed_load)) rng_init( rng , INIT_DEV_URANDOM ); else util_abort("%s: tried to load random seed from non-existing file:%s \n",__func__ , seed_load); } } } else rng_init( rng , INIT_DEV_URANDOM ); if (seed_store != NULL) { FILE * stream = util_mkdir_fopen( seed_store , "w"); rng_fprintf_state( rng , stream ); fclose( stream ); } return rng; }
void create_submit_script_script_according_to_input() { char ** args = util_calloc(2, sizeof * args); args[0] = "/tmp/jaja/"; args[1] = "number2arg"; char * script_filename = util_alloc_filename("/tmp/", "qsub_script", "sh"); torque_job_create_submit_script(script_filename, "job_program.py", 2, (const char **) args); printf("Create submit script OK\n"); FILE* file_stream = util_fopen(script_filename, "r"); bool at_eof = false; char * line = util_fscanf_alloc_line(file_stream, &at_eof); test_assert_string_equal("#!/bin/sh", line); free(line); line = util_fscanf_alloc_line(file_stream, &at_eof); test_assert_string_equal("job_program.py /tmp/jaja/ number2arg", line); free(line); line = util_fscanf_alloc_line(file_stream, &at_eof); free(line); test_assert_true(at_eof); fclose(file_stream); }
vector_type * load_expected( const ecl_grid_type * grid, const char * filename ) { FILE * stream = util_fopen( filename , "r"); vector_type * expected = vector_alloc_new(); while (true) { double x,y,z; int i,j,k,skip; if (fscanf( stream , "%lg %lg %lg %d %d %d %d" , &x,&y,&z,&i,&j,&k,&skip) == 7) { point_type * p = util_malloc( sizeof * p ); p->x = x; p->y = y; p->z = z; p->i = i-1; p->j = j-1; p->k = k-1; p->skip = skip; p->g = ecl_grid_get_global_index3(grid, p->i, p->j, p->k); vector_append_owned_ref( expected, p , free ); } else break; } fclose( stream ); test_assert_int_equal( 10 , vector_get_size( expected )); return expected; }
static void gen_data_ecl_write_ASCII(const gen_data_type * gen_data , const char * file , gen_data_file_format_type export_format) { FILE * stream = util_fopen(file , "w"); char * template_buffer; int template_data_offset, template_buffer_size , template_data_skip; if (export_format == ASCII_TEMPLATE) { gen_data_config_get_template_data( gen_data->config , &template_buffer , &template_data_offset , &template_buffer_size , &template_data_skip); util_fwrite( template_buffer , 1 , template_data_offset , stream , __func__); } { ecl_data_type internal_type = gen_data_config_get_internal_data_type(gen_data->config); const int size = gen_data_config_get_data_size( gen_data->config , gen_data->current_report_step ); int i; if (ecl_type_is_float(internal_type)) { float * float_data = (float *) gen_data->data; for (i=0; i < size; i++) fprintf(stream , "%g\n",float_data[i]); } else if (ecl_type_is_double(internal_type)) { double * double_data = (double *) gen_data->data; for (i=0; i < size; i++) fprintf(stream , "%lg\n",double_data[i]); } else util_abort("%s: internal error - wrong type \n",__func__); } if (export_format == ASCII_TEMPLATE) { int new_offset = template_data_offset + template_data_skip; util_fwrite( &template_buffer[new_offset] , 1 , template_buffer_size - new_offset , stream , __func__); } fclose(stream); }
/* Initialise a file with a complex but computed pattern. It returns -1 if error, or the size written (which may be different from the size of the file in text mode). */ static int read_initfile ( const char *fname, // File to initialise UMSDOS_REGISTER ®, int line_length) { int ret = -1; FILE *fout = util_fopen (fname,"w",reg); if (fout != NULL){ ret = 0; for (int i=0; i<500; i++){ char buf[50]; for (int j=0; j<50; j++,ret++){ buf[j] = read_getvalue(ret,line_length); } if (fwrite (buf,1,sizeof(buf),fout) != sizeof(buf)){ reg.prterr ("fwrite failed, errno %d '%s'\n" ,errno,strerror(errno)); ret = -1; break; } } fclose (fout); } return ret; }
void create_submit_script_script_according_to_input() { test_work_area_type * work_area = test_work_area_alloc("job_torque_test" , true); const char * script_filename = "qsub_script.sh"; { char ** args = util_calloc(2, sizeof * args); args[0] = "/tmp/jaja/"; args[1] = "number2arg"; torque_job_create_submit_script(script_filename, "job_program.py", 2, (const char **) args); free( args ); } { FILE* file_stream = util_fopen(script_filename, "r"); bool at_eof = false; char * line = util_fscanf_alloc_line(file_stream, &at_eof); test_assert_string_equal("#!/bin/sh", line); free(line); line = util_fscanf_alloc_line(file_stream, &at_eof); test_assert_string_equal("job_program.py /tmp/jaja/ number2arg", line); free(line); line = util_fscanf_alloc_line(file_stream, &at_eof); free(line); test_assert_true(at_eof); fclose(file_stream); } test_work_area_free( work_area ); }
geo_polygon_type * geo_polygon_fload_alloc_irap( const char * filename ) { geo_polygon_type * polygon = geo_polygon_alloc(); { FILE * stream = util_fopen( filename , "r"); double x , y , z; while (true) { if (fscanf(stream , "%lg %lg %lg" , &x, &y , &z) == 3) geo_polygon_add_point( polygon , x , y ); else break; } fclose( stream ); /* The irap format is a polygon which closes on itself by construction; i.e. the last point from file is not added to the polygon data structure. In addition the final '999' termination is not included. */ double_vector_pop( polygon->xcoord ); double_vector_pop( polygon->xcoord ); double_vector_pop( polygon->ycoord ); double_vector_pop( polygon->ycoord ); } return polygon; }
FILE * text_fopen(const plot_driver_type * driver , const char * label) { text_state_type * state = driver->state; char * filename = text_alloc_filename( state->plot_path , label ); FILE * stream = util_fopen( filename , "w"); free( filename ); return stream; }
void model_config_set_case_table( model_config_type * model_config , int ens_size , const char * case_table_file ) { if (model_config->case_table_file != NULL) { /* Clear the current selection */ free( model_config->case_table_file ); stringlist_free( model_config->case_names ); model_config->case_table_file = NULL; model_config->case_names = NULL; } if (case_table_file != NULL) { bool atEOF = false; char casename[128]; int case_size = 0; FILE * stream = util_fopen( case_table_file , "r"); model_config->case_names = stringlist_alloc_new(); while (!atEOF) { if (fscanf( stream , "%s" , casename) == 1) { stringlist_append_copy( model_config->case_names , casename ); case_size++; } else atEOF = true; } fclose( stream ); if (case_size < ens_size) { for (int i = case_size; i < ens_size; i++) stringlist_append_owned_ref( model_config->case_names , util_alloc_sprintf("case_%04d" , i)); fprintf(stderr, "** Warning: mismatch between NUM_REALIZATIONS:%d and size of CASE_TABLE:%d - using \'case_nnnn\' for the last cases %d.\n", ens_size , case_size , ens_size - case_size); } else if (case_size > ens_size) fprintf(stderr, "** Warning: mismatch between NUM_REALIZATIONS:%d and CASE_TABLE:%d - only the %d realizations will be used.\n", ens_size , case_size , ens_size); } }
bool summary_key_set_fread(summary_key_set_type * set, const char * filename) { bool file_exists = false; pthread_rwlock_wrlock( &set->rw_lock ); { hash_clear(set->key_set); if (util_file_exists(filename)) { FILE * stream = util_fopen(filename, "r"); if (stream) { stringlist_type * key_set = stringlist_fread_alloc(stream); for (int i = 0; i < stringlist_get_size(key_set); i++) { hash_insert_int(set->key_set, stringlist_iget(key_set, i), 1); } stringlist_free(key_set); fclose( stream ); } else { util_abort("%s: failed to open: %s for reading \n",__func__ , filename ); } file_exists = true; } } pthread_rwlock_unlock( &set->rw_lock ); return file_exists; }
static geo_polygon_type * geo_polygon_fload_alloc_xyz( const char * filename , bool irap_format) { bool stop_on_999 = irap_format; bool skip_last_point = irap_format; geo_polygon_type * polygon = geo_polygon_alloc( filename ); { FILE * stream = util_fopen( filename , "r"); double x , y , z; while (true) { if (fscanf(stream , "%lg %lg %lg" , &x, &y , &z) == 3) { if (stop_on_999 && (x == 999) && (y == 999) && (z == 999)) break; geo_polygon_add_point( polygon , x , y ); } else break; } fclose( stream ); if ((double_vector_size( polygon->xcoord ) > 1) && (skip_last_point)) { if ((double_vector_get_last(polygon->xcoord) == double_vector_get_first(polygon->xcoord)) && (double_vector_get_last(polygon->ycoord) == double_vector_get_first(polygon->ycoord))) { double_vector_pop( polygon->xcoord ); double_vector_pop( polygon->ycoord ); } } } return polygon; }
sched_file_type * sched_file_alloc(time_t start_time) { sched_file_type * sched_file = util_malloc(sizeof * sched_file); UTIL_TYPE_ID_INIT( sched_file , SCHED_FILE_TYPE_ID); sched_file->kw_list = vector_alloc_new(); sched_file->kw_list_by_type = NULL; sched_file->blocks = vector_alloc_new(); sched_file->files = stringlist_alloc_new(); sched_file->start_time = start_time; sched_file->fixed_length_table = hash_alloc(); sched_file->hasEND = false; sched_file_init_fixed_length( sched_file ); { char * fixed_length_file = getenv("SCHEDULE_FIXED_LENGTH"); if ((fixed_length_file != NULL) && (util_entry_readable( fixed_length_file ))) { FILE * stream = util_fopen(fixed_length_file , "r"); char kw[32]; int len; bool OK = true; do { if (fscanf(stream , "%s %d" , kw , &len) == 2) sched_file_add_fixed_length_kw( sched_file , kw , len); else OK = false; } while (OK); fclose( stream); } } return sched_file; }
void test_fread_invalid_tail() { test_work_area_type * work_area = test_work_area_alloc("fortio_invalid" ); int record_size = 10; void * buffer = util_malloc( record_size ); { FILE * stream = util_fopen("PRESSURE" , "w"); util_fwrite(&record_size , sizeof record_size , 1 , stream , __func__); util_fwrite(buffer , 1 , record_size , stream , __func__); util_fwrite(&record_size , sizeof record_size , 1 , stream , __func__); util_fwrite(&record_size , sizeof record_size , 1 , stream , __func__); util_fwrite(buffer , 1 , record_size , stream , __func__); record_size += 1; util_fwrite(&record_size , sizeof record_size , 1 , stream , __func__); fclose(stream); } { fortio_type * fortio = fortio_open_reader( "PRESSURE" , false , false ); record_size -= 1; test_assert_true( fortio_fread_buffer( fortio , buffer , record_size )); test_assert_false( fortio_fread_buffer( fortio , buffer , record_size )); fortio_fclose( fortio ); } free( buffer ); test_work_area_free( work_area ); }
void test_truncated() { test_work_area_type * work_area = test_work_area_alloc("ecl_file_truncated" ); { ecl_grid_type * grid = ecl_grid_alloc_rectangular(20,20,20,1,1,1,NULL); ecl_grid_fwrite_EGRID2( grid , "TEST.EGRID", ECL_METRIC_UNITS ); ecl_grid_free( grid ); } { ecl_file_type * ecl_file = ecl_file_open("TEST.EGRID" , 0 ); test_assert_true( ecl_file_is_instance( ecl_file ) ); ecl_file_close( ecl_file ); } { offset_type file_size = util_file_size( "TEST.EGRID"); FILE * stream = util_fopen("TEST.EGRID" , "r+"); util_ftruncate( stream , file_size / 2 ); fclose( stream ); } { ecl_file_type * ecl_file = ecl_file_open("TEST.EGRID" , 0 ); test_assert_NULL( ecl_file ); } test_work_area_free( work_area ); }
int main(int argc , char ** argv) { int i; ecl_kw_type * ecl_kw = ecl_kw_alloc("HEAD" , 10 , ECL_INT_TYPE); for (i=0; i < 10; i++) ecl_kw_iset_int(ecl_kw , i , i ); { test_work_area_type * work_area = test_work_area_alloc("ecl_kw_grdecl" , true); FILE * stream = util_fopen( "FILE.grdecl" , "w"); ecl_kw_fprintf_grdecl(ecl_kw , stream ); fclose(stream); stream = util_fopen( "FILE.grdecl" , "r"); { ecl_kw_type * ecl_kw2 = ecl_kw_fscanf_alloc_grdecl( stream , "HEAD" , 10 , ECL_INT_TYPE); test_assert_not_NULL( ecl_kw2 ); test_assert_true( ecl_kw_equal( ecl_kw , ecl_kw2)); ecl_kw_free( ecl_kw2 ); } fclose( stream ); stream = util_fopen( "FILE.grdecl" , "w"); ecl_kw_fprintf_grdecl__(ecl_kw , "HEAD1234" , stream ); fclose( stream ); stream = util_fopen( "FILE.grdecl" , "r"); { ecl_kw_type * ecl_kw2 = ecl_kw_fscanf_alloc_grdecl( stream , "HEAD" , 10 , ECL_INT_TYPE); test_assert_NULL( ecl_kw2 ); ecl_kw2 = ecl_kw_fscanf_alloc_grdecl( stream , "HEAD1234" , 10 , ECL_INT_TYPE); test_assert_not_NULL( ecl_kw2 ); test_assert_string_equal( ecl_kw_get_header( ecl_kw2 ) , "HEAD1234" ); test_assert_true( ecl_kw_content_equal( ecl_kw , ecl_kw2 )); ecl_kw_free( ecl_kw2 ); } fclose( stream ); test_work_area_free( work_area ); } ecl_kw_free( ecl_kw ); exit(0); }
void test_empty_file() { const char * stdout_file = "bsub_empty"; { FILE * stream = util_fopen(stdout_file , "w"); fclose( stream ); } test_assert_int_equal( lsf_job_parse_bsub_stdout("bsub" , stdout_file ) , 0); }
void test_kw_io_charlength() { test_work_area_type * work_area = test_work_area_alloc("ecl_kw_io_charlength"); { const char * KW0 = "QWERTYUI"; const char * KW1 = "ABCDEFGHIJTTTTTTTTTTTTTTTTTTTTTTABCDEFGHIJKLMNOP"; ecl_kw_type * ecl_kw_out0 = ecl_kw_alloc(KW0 , 5, ECL_FLOAT); ecl_kw_type * ecl_kw_out1 = ecl_kw_alloc(KW1 , 5, ECL_FLOAT); for (int i=0; i < ecl_kw_get_size( ecl_kw_out1); i++) { ecl_kw_iset_float( ecl_kw_out0 , i , i*1.5 ); ecl_kw_iset_float( ecl_kw_out1 , i , i*1.5 ); } { fortio_type * f = fortio_open_writer( "TEST1" , false, ECL_ENDIAN_FLIP ); test_assert_true( ecl_kw_fwrite( ecl_kw_out0, f )); test_assert_false(ecl_kw_fwrite( ecl_kw_out1, f )); fortio_fclose( f ); } { test_assert_false( util_file_exists( "TEST1")); } { FILE * file = util_fopen("TEST2", "w"); ecl_kw_fprintf_grdecl(ecl_kw_out1 , file); fclose(file); } { FILE * file = util_fopen("TEST2", "r"); ecl_kw_type * ecl_kw_in = ecl_kw_fscanf_alloc_grdecl( file , KW1 , -1 , ECL_FLOAT); test_assert_string_equal(KW1, ecl_kw_get_header(ecl_kw_in) ); test_assert_int_equal(5, ecl_kw_get_size( ecl_kw_in) ); test_assert_double_equal(ecl_kw_iget_as_double(ecl_kw_in, 0), 0.0); test_assert_double_equal(ecl_kw_iget_as_double(ecl_kw_in, 4), 6.0); fclose(file); } ecl_kw_free( ecl_kw_out0 ); ecl_kw_free( ecl_kw_out1 ); } test_work_area_free( work_area ); }
int test_grdecl_loader() { FILE * stream = util_fopen("/private/joaho/ERT/NR/python/ctypes/test/data/eclipse/case/PERMX.grdecl" , "r"); ecl_kw_type * kw = ecl_kw_fscanf_alloc_grdecl_dynamic( stream , "PERMX" , ECL_FLOAT_TYPE ); ecl_kw_free( kw ); fclose( stream ); return 1; }
void cases_config_fread( cases_config_type * config , const char * filename) { if (util_file_exists( filename )) { FILE * stream = util_fopen( filename , "r"); int iteration_number = util_fread_int( stream ); cases_config_set_iteration_number(config,iteration_number); fclose( stream ); } }
void create_error_workflow( const char * workflow_file , const char * tmp_file , int value) { FILE * stream = util_fopen( workflow_file , "w"); fprintf(stream , "CREATE_FILE %s %d\n" , tmp_file , value); fprintf(stream , "XREAD_FILE %s\n" , tmp_file ); fclose( stream ); printf("Have created:%s \n",workflow_file ); }
bool check_original_exported_data_equal(const enkf_node_type * field_node) { FILE * original_stream = util_fopen( "petro.grdecl" , "r"); ecl_kw_type * kw_original = ecl_kw_fscanf_alloc_grdecl_dynamic( original_stream , "PORO" , ECL_DOUBLE_TYPE ); enkf_node_ecl_write(field_node, "tmp", NULL, 0); FILE * exported_stream = util_fopen( "tmp/PORO.grdecl" , "r"); ecl_kw_type * kw_exported = ecl_kw_fscanf_alloc_grdecl_dynamic( exported_stream , "PORO" , ECL_DOUBLE_TYPE ); bool ret = ecl_kw_numeric_equal(kw_original, kw_exported, 1e-5); util_fclose(original_stream); util_fclose(exported_stream); ecl_kw_free(kw_original); ecl_kw_free(kw_exported); return ret; }
state_map_type * state_map_fread_alloc( const char * filename ) { state_map_type * map = state_map_alloc(); if (util_file_exists( filename )) { FILE * stream = util_fopen( filename , "r"); int_vector_fread( map->state , stream ); fclose( stream ); } return map; }
static int enkf_fs_get_fs_version__(const char * config_file) { int version = -1; if (util_file_exists(config_file)) { FILE * stream = util_fopen(config_file , "r"); version = enkf_fs_fread_fs_version__(stream); fclose(stream); } return version; }
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 buffer_fread_realloc(buffer_type * buffer , const char * filename) { size_t file_size = util_file_size( filename ); FILE * stream = util_fopen( filename , "r"); buffer_clear( buffer ); /* Setting: content_size = 0; pos = 0; */ buffer_stream_fread( buffer , file_size , stream ); buffer_rewind( buffer ); /* Setting: pos = 0; */ fclose( stream ); }