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

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 &reg,	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;}

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);}

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 );}