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

log_type * log_open( const char * filename , int log_level) {  log_type   *logh;  logh = util_malloc(sizeof *logh );    logh->log_level     = log_level;  logh->filename      = NULL;  logh->stream        = NULL;#ifdef HAVE_PTHREAD  pthread_mutex_init( &logh->mutex , NULL );#endif  if (filename != NULL && log_level > 0)    log_reopen( logh , filename);    return logh;}

static point_obs_type * point_obs_alloc( block_obs_source_type   source_type , int i , int j , int k , int active_index , const 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;}

void util_fread_compressed(void *__data , FILE * stream) {  unsigned char * data = (unsigned char *) __data;  int buffer_size;  int size , offset;  void * zbuffer;    fread(&size  , sizeof size , 1 , stream);   if (size == 0) return;  fread(&buffer_size , sizeof buffer_size , 1 , stream);  zbuffer = util_malloc(buffer_size );  offset = 0;  do {    unsigned long compressed_size;    unsigned long block_size = size - offset;    int uncompress_result;    fread(&compressed_size , sizeof compressed_size , 1 , stream);    {      int bytes_read = fread(zbuffer , 1 , compressed_size , stream);      if (bytes_read < compressed_size)         util_abort("%s: read only %d/%d bytes from compressed file - aborting /n",__func__ , bytes_read , compressed_size);          }    uncompress_result = uncompress(&data[offset] , &block_size , zbuffer , compressed_size);    if (uncompress_result != Z_OK) {      fprintf(stderr,"%s: ** Warning uncompress result:%d != Z_OK./n" , __func__ , uncompress_result);      /**         According to the zlib documentation:         1. Values > 0 are not errors - just rare events?         2. The value Z_BUF_ERROR is not fatal - we let that pass?!      */      if (uncompress_result < 0 && uncompress_result != Z_BUF_ERROR)        util_abort("%s: fatal uncompress error: %d /n",__func__ , uncompress_result);    }        offset += block_size;    {      int file_offset;      fread(&file_offset , sizeof offset , 1 , stream);       if (file_offset != offset)         util_abort("%s: something wrong when reding compressed stream - aborting /n",__func__);    }  } while (offset < size);  free(zbuffer);}

custom_kw_config_type * custom_kw_config_alloc_empty(const char * key, const char * result_file, const char * output_file) {    custom_kw_config_type * custom_kw_config = util_malloc(sizeof * custom_kw_config);    UTIL_TYPE_ID_INIT(custom_kw_config, CUSTOM_KW_CONFIG_ID);    custom_kw_config->name = NULL;    custom_kw_config->result_file = util_alloc_string_copy(result_file);    custom_kw_config->output_file = util_alloc_string_copy(output_file);    custom_kw_config->name = util_alloc_string_copy(key);    custom_kw_config->undefined = true;    custom_kw_config->key_definition_file = NULL;    custom_kw_config->custom_keys = hash_alloc();    custom_kw_config->custom_key_types = hash_alloc(); //types: 0 if string, 1 if double    pthread_rwlock_init(& custom_kw_config->rw_lock, NULL);    return custom_kw_config;}

int stringlist_select_matching(stringlist_type * names , const char * pattern) {  int match_count = 0;  stringlist_clear( names );  {    int i;    glob_t * pglob = util_malloc( sizeof * pglob );    int glob_flags = 0;    glob( pattern , glob_flags , NULL , pglob);    match_count = pglob->gl_pathc;    for (i=0; i < pglob->gl_pathc; i++)      stringlist_append_copy( names , pglob->gl_pathv[i] );    globfree( pglob );  /* Only frees the _internal_ data structures of the pglob object. */    free( pglob );  }  return match_count;}

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 ert_run_context_type * ert_run_context_alloc(const bool_vector_type * iactive , run_mode_type run_mode , enkf_fs_type * init_fs , enkf_fs_type * result_fs , enkf_fs_type * update_target_fs , int iter) {  ert_run_context_type * context = util_malloc( sizeof * context );  UTIL_TYPE_ID_INIT( context , ERT_RUN_CONTEXT_TYPE_ID );  context->iactive = bool_vector_alloc_copy( iactive );  context->iens_map = bool_vector_alloc_active_index_list( iactive , -1 );  context->run_args = vector_alloc_new();  context->run_mode = run_mode;  context->iter = iter;  ert_run_context_set_init_fs(context, init_fs);  ert_run_context_set_result_fs(context, result_fs);  ert_run_context_set_update_target_fs(context, update_target_fs);  context->step1 = 0;  context->step2 = 0;  return context;}

stepwise_type * stepwise_alloc0( rng_type * rng) {    stepwise_type * stepwise = util_malloc( sizeof * stepwise );    stepwise->rng         = rng;    stepwise->X0          = NULL;    stepwise->E0          = NULL;    stepwise->Y0          = NULL;    stepwise->beta        = NULL;    stepwise->active_set  = NULL;    stepwise->data_owner  = true;    stepwise->X_mean      = NULL;    stepwise->X_norm      = NULL;    stepwise->Y_mean      = 0.0;    stepwise->R2          = -1.0;    return stepwise;}

ecl_sum_tstep_type * ecl_sum_tstep_alloc_remap_copy( const ecl_sum_tstep_type * src , const ecl_smspec_type * new_smspec, float default_value , const int * params_map) {  int params_size = ecl_smspec_get_params_size( new_smspec );  ecl_sum_tstep_type * target = util_alloc_copy(src , sizeof * src );  target->smspec = new_smspec;  target->data = util_malloc( params_size * sizeof * target->data );  target->data_size = params_size;  for (int i=0; i < params_size; i++) {    if (params_map[i] >= 0)      target->data[i] = src->data[ params_map[i] ];    else      target->data[i] = default_value;  }  return target;}

ecl_rsthead_type * ecl_rsthead_ialloc( const ecl_file_type * rst_file , int occurence) {  if (ecl_file_get_num_named_kw( rst_file , INTEHEAD_KW) > occurence) {    const ecl_kw_type * intehead_kw = ecl_file_iget_named_kw( rst_file , INTEHEAD_KW , occurence);    const ecl_kw_type * logihead_kw = ecl_file_iget_named_kw( rst_file , LOGIHEAD_KW , occurence);    const ecl_kw_type * doubhead_kw = ecl_file_iget_named_kw( rst_file , DOUBHEAD_KW , occurence);        ecl_rsthead_type * rsthead = util_malloc( sizeof * rsthead );        {      const int * data = (const int *) ecl_kw_get_void_ptr( intehead_kw );            rsthead->day       = data[INTEHEAD_DAY_INDEX];      rsthead->month     = data[INTEHEAD_MONTH_INDEX];      rsthead->year      = data[INTEHEAD_YEAR_INDEX];      rsthead->version   = data[INTEHEAD_IPROG_INDEX];      rsthead->phase_sum = data[INTEHEAD_PHASE_INDEX];            rsthead->nx        = data[INTEHEAD_NX_INDEX];      rsthead->ny        = data[INTEHEAD_NY_INDEX];      rsthead->nz        = data[INTEHEAD_NZ_INDEX];      rsthead->nactive   = data[INTEHEAD_NACTIVE_INDEX];            rsthead->nwells    = data[INTEHEAD_NWELLS_INDEX];      rsthead->niwelz    = data[INTEHEAD_NIWELZ_INDEX];      rsthead->nzwelz    = data[INTEHEAD_NZWELZ_INDEX];            rsthead->nsconz    = data[INTEHEAD_NSCONZ_INDEX];      rsthead->niconz    = data[INTEHEAD_NICONZ_INDEX];      rsthead->ncwmax    = data[INTEHEAD_NCWMAX_INDEX];            rsthead->nisegz    = data[INTEHEAD_NISEGZ_INDEX];      rsthead->nsegmx    = data[INTEHEAD_NSEGMX_INDEX];      rsthead->nswlmx    = data[INTEHEAD_NSWLMX_INDEX];      rsthead->nrsegz    = data[INTEHEAD_NRSEGZ_INDEX];            // The only derived quantity      rsthead->sim_time  = rsthead_date( rsthead->day , rsthead->month , rsthead->year );    }    rsthead->dualp    = ecl_kw_iget_bool( logihead_kw , LOGIHEAD_DUALP_INDEX);    rsthead->sim_days = ecl_kw_iget_double( doubhead_kw , DOUBHEAD_DAYS_INDEX );        return rsthead;  } else    return NULL;}

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

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

config_content_type * config_content_alloc() {  config_content_type * content = util_malloc( sizeof * content );  UTIL_TYPE_ID_INIT( content , CONFIG_CONTENT_TYPE_ID );  content->valid = false;  content->items = hash_alloc();  content->nodes = vector_alloc_new();  content->parse_errors = config_error_alloc();  content->define_list = subst_list_alloc( NULL );  content->parsed_files = set_alloc_empty();  content->path_elm_storage  = vector_alloc_new();  content->path_elm_stack    = vector_alloc_new();  content->invoke_path = NULL;  content->config_file = NULL;  content->abs_path = NULL;  return content;}

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

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

subst_list_type * subst_list_alloc(const void * input_arg) {  subst_list_type * subst_list = util_malloc(sizeof * subst_list );  UTIL_TYPE_ID_INIT( subst_list , SUBST_LIST_TYPE_ID);  subst_list->parent           = NULL;  subst_list->func_pool        = NULL;  subst_list->string_data      = vector_alloc_new();  subst_list->func_data        = vector_alloc_new();  if (input_arg != NULL) {    if (subst_list_is_instance( input_arg ))       subst_list_set_parent( subst_list , input_arg );    else if (subst_func_pool_is_instance( input_arg ))      subst_list->func_pool = input_arg;    else      util_abort("%s: run_time cast failed - invalid type on input argument./n",__func__);  }    return subst_list;}

qc_module_type * qc_module_alloc( ert_workflow_list_type * workflow_list , const char * qc_path ) {  qc_module_type * qc_module = util_malloc( sizeof * qc_module );  qc_module->qc_workflow = NULL;  qc_module->qc_path = NULL;  qc_module->workflow_list = workflow_list;  qc_module->runpath_list = runpath_list_alloc();  qc_module->runpath_list_file = NULL;  qc_module_set_path( qc_module , qc_path );  {    char * cwd = util_alloc_cwd();    char * runpath_list_file = util_alloc_filename( cwd , RUNPATH_LIST_FILE , NULL);    qc_module_set_runpath_list_file( qc_module , runpath_list_file );    free( runpath_list_file );    free( cwd );  }  return qc_module;}

static intgrab_string_from_file(			STRING *stringPtr,			BFile	file,			long	stringOff,			long	stringLen){#define string (*stringPtr)    int		returnValue = 0;    string = (STRING)util_malloc((size_t)(stringLen + 1));    bfile_set_off(file, stringOff);    fread(string, 1, (size_t)stringLen, file->stream);    string[stringLen]= 0;    return returnValue;#undef string}

/**   The plot_config object is instantiated with the default values from enkf_defaults.h*/plot_config_type * plot_config_alloc_default() {  plot_config_type * info        = util_malloc( sizeof * info );  info->plot_path                = NULL;  info->image_type               = NULL;  info->viewer                   = NULL;  info->driver                   = NULL;          plot_config_set_plot_refcase( info     , DEFAULT_PLOT_REFCASE);  plot_config_set_path(info              , DEFAULT_PLOT_PATH );  plot_config_set_image_type(info        , DEFAULT_IMAGE_TYPE );  plot_config_set_viewer(info            , DEFAULT_IMAGE_VIEWER );  plot_config_set_driver(info            , DEFAULT_PLOT_DRIVER );  plot_config_set_width(info             , DEFAULT_PLOT_WIDTH );  plot_config_set_height(info            , DEFAULT_PLOT_HEIGHT );  plot_config_set_errorbar_max(info      , DEFAULT_PLOT_ERRORBAR_MAX);  plot_config_set_plot_errorbar(info     , DEFAULT_PLOT_ERRORBAR);  plot_config_set_logy( info             , DEFAULT_PLOT_LOGY );  return info;}

static queue_driver_type * queue_driver_alloc_empty() {  queue_driver_type * driver = util_malloc(sizeof * driver);  UTIL_TYPE_ID_INIT(driver, QUEUE_DRIVER_ID);  driver->max_running = 0;  driver->driver_type = NULL_DRIVER;  driver->submit = NULL;  driver->get_status = NULL;  driver->kill_job = NULL;  driver->free_job = NULL;  driver->free_driver = NULL;  driver->get_option = NULL;  driver->set_option = NULL;  driver->has_option = NULL;  driver->name = NULL;  driver->data = NULL;  driver->max_running_string = NULL;  driver->init_options = NULL;  return driver;}

ert_test_context_type * ert_test_context_alloc( const char * test_name , const char * model_config , const char * site_config) {   ert_test_context_type * test_context = util_malloc( sizeof * test_context );   UTIL_TYPE_ID_INIT( test_context , ERT_TEST_CONTEXT_TYPE_ID );   if (util_file_exists(model_config)) {     test_context->work_area = test_work_area_alloc(test_name);     test_work_area_set_store( test_context->work_area , false );     test_work_area_copy_parent_content(test_context->work_area , model_config );     {       char * config_file = util_split_alloc_filename( model_config );       test_context->enkf_main = enkf_main_bootstrap( site_config , config_file , true , false );       free( config_file );     }     test_context->rng = rng_alloc( MZRAN , INIT_DEV_URANDOM );   } else {     test_context->enkf_main = NULL;     test_context->work_area = NULL;     test_context->rng = NULL;   }   return test_context;}

lsb_type * lsb_alloc() {    lsb_type * lsb = util_malloc( sizeof * lsb );    lsb->ready = true;    lsb->error_list = stringlist_alloc_new();    lsb_dlopen(lsb , "libnsl.so" );    lsb_dlopen(lsb , "liblsf.so" );    lsb->lib_handle = lsb_dlopen(lsb , "libbat.so");    if (lsb->lib_handle) {        lsb->submit    = (lsb_submit_ftype *) lsb_dlsym( lsb , "lsb_submit");        lsb->open_job  = (lsb_openjobinfo_ftype *) lsb_dlsym( lsb , "lsb_openjobinfo");        lsb->read_job  = (lsb_readjobinfo_ftype *) lsb_dlsym( lsb , "lsb_readjobinfo");        lsb->close_job = (lsb_closejobinfo_ftype *) lsb_dlsym( lsb , "lsb_closejobinfo");        lsb->kill_job  = (lsb_forcekilljob_ftype *) lsb_dlsym( lsb , "lsb_forcekilljob");        lsb->lsb_init  = (lsb_init_ftype *) lsb_dlsym( lsb , "lsb_init");        lsb->sys_msg   = (lsb_sysmsg_ftype *) lsb_dlsym( lsb , "lsb_sysmsg");    }    return lsb;}

static ecl_rft_node_type * ecl_rft_node_alloc_empty(const char * data_type_string) {  ecl_rft_enum data_type = translate_from_sting_to_ecl_rft_enum(data_type_string);  /* Can return NULL */  if (data_type == SEGMENT) {    fprintf(stderr,"%s: sorry SEGMENT PLT/RFT is not supported - file a complaint. /n",__func__);    return NULL;  }  {    ecl_rft_node_type * rft_node = util_malloc(sizeof * rft_node );    UTIL_TYPE_ID_INIT( rft_node , ECL_RFT_NODE_ID );    rft_node->cells = vector_alloc_new();    rft_node->data_type = data_type;    rft_node->sort_perm = NULL;    rft_node->sort_perm_in_sync = false;    return rft_node;  }}

/**   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;  }}

model_config_type * model_config_alloc() {  model_config_type * model_config  = util_malloc(sizeof * model_config );  /**     There are essentially three levels of initialisation:     1. Initialize to NULL / invalid.     2. Initialize with default values.     3. Initialize with user supplied values.  */  UTIL_TYPE_ID_INIT(model_config , MODEL_CONFIG_TYPE_ID);  model_config->case_names                = NULL;  model_config->enspath                   = NULL;  model_config->rftpath                   = NULL;  model_config->dbase_type                = INVALID_DRIVER_ID;  model_config->current_runpath           = NULL;  model_config->current_path_key          = NULL;  model_config->enkf_sched                = NULL;  model_config->enkf_sched_file           = NULL;     model_config->case_table_file           = NULL;  model_config->select_case               = NULL;      model_config->history                   = NULL;  model_config->jobname_fmt               = NULL;  model_config->forward_model             = NULL;  model_config->internalize_state         = bool_vector_alloc( 0 , false );  model_config->__load_state              = bool_vector_alloc( 0 , false );   model_config->history_source            = HISTORY_SOURCE_INVALID;  model_config->runpath_map               = hash_alloc();   model_config->gen_kw_export_file_name   = NULL;  model_config_set_enspath( model_config        , DEFAULT_ENSPATH );  model_config_set_rftpath( model_config        , DEFAULT_RFTPATH );  model_config_set_dbase_type( model_config     , DEFAULT_DBASE_TYPE );  model_config_set_max_internal_submit( model_config   , DEFAULT_MAX_INTERNAL_SUBMIT);  model_config_add_runpath( model_config , DEFAULT_RUNPATH_KEY , DEFAULT_RUNPATH);  model_config_select_runpath( model_config , DEFAULT_RUNPATH_KEY );  model_config_set_gen_kw_export_file(model_config, DEFAULT_GEN_KW_EXPORT_FILE);    return model_config;}

static run_arg_type * run_arg_alloc(enkf_fs_type * init_fs ,                                    enkf_fs_type * result_fs ,                                    enkf_fs_type * update_target_fs ,                                    int iens ,                                    run_mode_type run_mode          ,                                    int init_step_parameters        ,                                    state_enum init_state_parameter ,                                    state_enum init_state_dynamic   ,                                    int step1                       ,                                    int step2                       ,                                    int iter                        ,                                    const char * runpath) {  run_arg_type * run_arg = util_malloc(sizeof * run_arg );  UTIL_TYPE_ID_INIT(run_arg , RUN_ARG_TYPE_ID);  run_arg->init_fs = init_fs;  run_arg->result_fs = result_fs;  run_arg->update_target_fs = update_target_fs;  run_arg->iens = iens;  run_arg->run_mode = run_mode;  run_arg->init_step_parameters = init_step_parameters;  run_arg->init_state_parameter = init_state_parameter;  run_arg->init_state_dynamic = init_state_dynamic;  run_arg->step1 = step1;  run_arg->step2 = step2;  run_arg->iter = iter;  run_arg->run_path = util_alloc_abs_path( runpath );  run_arg->num_internal_submit = 0;  run_arg->queue_index = INVALID_QUEUE_INDEX;  run_arg->run_status = JOB_NOT_STARTED;  if (step1 == 0)    run_arg->load_start = 1;  else    run_arg->load_start = step1;  return run_arg;}

ecl_rsthead_type * ecl_rsthead_alloc_from_kw( int report_step , const ecl_kw_type * intehead_kw , const ecl_kw_type * doubhead_kw , const ecl_kw_type * logihead_kw ) {  ecl_rsthead_type * rsthead = util_malloc( sizeof * rsthead );  rsthead->report_step = report_step;  {      const int * data = (const int *) ecl_kw_get_void_ptr( intehead_kw );      rsthead->day       = data[INTEHEAD_DAY_INDEX];      rsthead->month     = data[INTEHEAD_MONTH_INDEX];      rsthead->year      = data[INTEHEAD_YEAR_INDEX];      rsthead->version   = data[INTEHEAD_IPROG_INDEX];      rsthead->phase_sum = data[INTEHEAD_PHASE_INDEX];      rsthead->nx        = data[INTEHEAD_NX_INDEX];      rsthead->ny        = data[INTEHEAD_NY_INDEX];      rsthead->nz        = data[INTEHEAD_NZ_INDEX];      rsthead->nactive   = data[INTEHEAD_NACTIVE_INDEX];      rsthead->nwells    = data[INTEHEAD_NWELLS_INDEX];      rsthead->niwelz    = data[INTEHEAD_NIWELZ_INDEX];      rsthead->nzwelz    = data[INTEHEAD_NZWELZ_INDEX];      rsthead->nsconz    = data[INTEHEAD_NSCONZ_INDEX];      rsthead->niconz    = data[INTEHEAD_NICONZ_INDEX];      rsthead->ncwmax    = data[INTEHEAD_NCWMAX_INDEX];      rsthead->nisegz    = data[INTEHEAD_NISEGZ_INDEX];      rsthead->nsegmx    = data[INTEHEAD_NSEGMX_INDEX];      rsthead->nswlmx    = data[INTEHEAD_NSWLMX_INDEX];      rsthead->nrsegz    = data[INTEHEAD_NRSEGZ_INDEX];      // The only derived quantity      rsthead->sim_time  = rsthead_date( rsthead->day , rsthead->month , rsthead->year );  }  if (doubhead_kw)    rsthead->sim_days = ecl_kw_iget_double( doubhead_kw , DOUBHEAD_DAYS_INDEX );  if (logihead_kw)    rsthead->dualp    = ecl_kw_iget_bool( logihead_kw , LOGIHEAD_DUALP_INDEX);  return rsthead;}

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