int fortio_fseek( fortio_type * fortio , offset_type offset , int whence) { int fseek_return = util_fseek( fortio->stream , offset , whence ); /* if fseek_return != 0 -> util_abort(). */ return fseek_return; }
bool ecl_kw_grdecl_fseek_kw(const char * kw , bool rewind , FILE * stream) { if (ecl_kw_grdecl_fseek_kw__(kw , stream)) return true; /* OK - we found the kw between current file pos and EOF. */ else if (rewind) { long int init_pos = util_ftell(stream); util_fseek(stream , 0L , SEEK_SET); if (ecl_kw_grdecl_fseek_kw__( kw , stream )) /* Try again from the beginning of the file. */ return true; else util_fseek(stream , init_pos , SEEK_SET); /* Could not find it - reposition to initial position. */ } /* OK: If we are here - that means that we failed to find the kw. */ return false; }
static int ecl_util_get_num_parallel_cpu__(parser_type* parser, FILE* stream, const char * data_file) { int num_cpu = 1; char * buffer; long int start_pos = util_ftell( stream ); int buffer_size; /* Look for terminating '/' */ if (!parser_fseek_string( parser , stream , "/" , false , true)) util_abort("%s: sorry - could not find \"/\" termination of PARALLEL keyword in data_file: \n",__func__ , data_file); buffer_size = (util_ftell(stream) - start_pos) ; buffer = util_calloc( buffer_size + 1 , sizeof * buffer ); util_fseek( stream , start_pos , SEEK_SET); util_fread( buffer , sizeof * buffer , buffer_size ,stream , __func__); buffer[buffer_size] = '\0'; { stringlist_type * tokens = parser_tokenize_buffer( parser , buffer , true ); if (stringlist_get_size( tokens ) > 0) { const char * num_cpu_string = stringlist_iget( tokens , 0 ); if (!util_sscanf_int( num_cpu_string , &num_cpu)) fprintf(stderr,"** Warning: failed to interpret:%s as integer - assuming one CPU\n",num_cpu_string); } else fprintf(stderr,"** Warning: failed to load data for PARALLEL keyword - assuming one CPU\n"); stringlist_free( tokens ); } free( buffer ); return num_cpu; }
static bool ecl_kw_grdecl_fseek_kw__(const char * kw , FILE * stream) { long init_pos = util_ftell( stream ); while (true) { if (ecl_kw_grdecl_fseek_next_kw( stream )) { char next_kw[256]; fscanf( stream , "%s" , next_kw); if (strcmp( kw , next_kw ) == 0) { offset_type offset = (offset_type) strlen(next_kw); util_fseek( stream , -offset , SEEK_CUR); return true; } } else { util_fseek( stream , init_pos , SEEK_SET); return false; } } }
static bool fortio_is_fortran_stream__(FILE * stream , bool endian_flip) { const bool strict_checking = true; /* True: requires that *ALL* records in the file are fortran formatted */ offset_type init_pos = util_ftell(stream); bool is_fortran_stream = false; int header , tail; bool cont; do { cont = false; if (__read_int(stream , &header , endian_flip)) { if (header >= 0) { if (util_fseek(stream , (offset_type) header , SEEK_CUR) == 0) { if (__read_int(stream , &tail , endian_flip)) { cont = true; /* OK - now we have read a header and a tail - it might be a fortran file. */ if (header == tail) { if (header != 0) { /* This is (most probably) a fortran file */ is_fortran_stream = true; if (strict_checking) cont = true; else cont = false; } /* Header == tail == 0 - we don't make any inference on this. */ } else { /* Header != tail => this is *not* a fortran file */ cont = false; is_fortran_stream = false; } } } } } } while (cont); util_fseek(stream , init_pos , SEEK_SET); return is_fortran_stream; }
static bool rms_tag_at_endtag(FILE *stream) { const int init_pos = util_ftell(stream); bool at_endtag; char tag[7]; if (rms_util_fread_string(tag , 7 , stream)) { if (strcmp(tag , rms_endtag_string) == 0) at_endtag = true; else at_endtag = false; } else at_endtag = false; if (!at_endtag) util_fseek(stream , init_pos , SEEK_SET); return at_endtag; }
static bool fgetc_while_equal( FILE * stream , const char * string , bool case_sensitive) { bool equal = true; long int current_pos = util_ftell(stream); int string_index; for ( string_index = 0; string_index < strlen(string); string_index++) { int c = fgetc( stream ); if (!case_sensitive) c = toupper( c ); if (c != string[string_index]) { equal = false; break; } } if (!equal) /* OK - not equal - go back. */ util_fseek( stream , current_pos , SEEK_SET); return equal; }
time_t ecl_util_get_start_date(const char * data_file) { parser_type * parser = parser_alloc(" \t\r\n" , "\"\'" , NULL , NULL , "--" , "\n"); time_t start_date = -1; FILE * stream = util_fopen(data_file , "r"); char * buffer; if (!parser_fseek_string( parser , stream , "START" , true , true)) /* Seeks case insensitive. */ util_abort("%s: sorry - could not find START in DATA file %s \n",__func__ , data_file); { long int start_pos = util_ftell( stream ); int buffer_size; /* Look for terminating '/' */ if (!parser_fseek_string( parser , stream , "/" , false , true)) util_abort("%s: sorry - could not find \"/\" termination of START keyword in data_file: \n",__func__ , data_file); buffer_size = (util_ftell(stream) - start_pos) ; buffer = util_calloc( buffer_size + 1 , sizeof * buffer ); util_fseek( stream , start_pos , SEEK_SET); util_fread( buffer , sizeof * buffer , buffer_size ,stream , __func__); buffer[buffer_size] = '\0'; } { stringlist_type * tokens = parser_tokenize_buffer( parser , buffer , true ); int day, year, month_nr; if ( util_sscanf_int( stringlist_iget( tokens , 0 ) , &day) && util_sscanf_int( stringlist_iget(tokens , 2) , &year)) { month_nr = ecl_util_get_month_nr(stringlist_iget( tokens , 1)); start_date = ecl_util_make_date(day , month_nr , year ); } else util_abort("%s: failed to parse DAY MONTH YEAR from : \"%s\" \n",__func__ , buffer); stringlist_free( tokens ); } free( buffer ); parser_free( parser ); fclose(stream); return start_date; }
void test_readwrite() { test_work_area_type * test_area = test_work_area_alloc("matrix-test"); { rng_type * rng = rng_alloc(MZRAN , INIT_DEV_URANDOM ); matrix_type * m1 = matrix_alloc(3 , 3); matrix_type * m2 = matrix_alloc(3 , 3); matrix_random_init( m1 , rng ); matrix_assign(m2 , m1); test_assert_true( matrix_equal( m1 , m2 ) ); { FILE * stream = util_fopen("m1" , "w"); matrix_fwrite( m1 , stream ); fclose( stream ); } matrix_random_init( m1 , rng ); test_assert_false( matrix_equal( m1 , m2 ) ); { FILE * stream = util_fopen("m1" , "r"); matrix_free( m1 ); m1 = matrix_alloc(1,1); printf("-----------------------------------------------------------------\n"); matrix_fread( m1 , stream ); test_assert_int_equal( matrix_get_rows(m1) , matrix_get_rows( m2)); test_assert_int_equal( matrix_get_columns(m1) , matrix_get_columns( m2)); util_fseek( stream , 0 , SEEK_SET); { matrix_type * m3 = matrix_fread_alloc( stream ); test_assert_true( matrix_equal( m2 , m3 )); matrix_free( m3 ); } fclose( stream ); } test_assert_true( matrix_equal( m1 , m2 ) ); matrix_free( m2 ); matrix_free( m1 ); rng_free( rng ); } test_work_area_free( test_area ); }
static fortio_status_type fortio_check_record( FILE * stream , bool endian_flip , int * record_size) { int read_count; int header, tail; fortio_status_type status; read_count = fread( &header , sizeof header , 1 , stream ); if (read_count == 0) status = FORTIO_EOF; else { if (endian_flip) util_endian_flip_vector(&header , sizeof header , 1); if (util_fseek( stream , (offset_type) header , SEEK_CUR ) != 0) /* The fseek() failed - i.e. the data section was not sufficiently long. */ status = FORTIO_MISSING_DATA; else { read_count = fread( &tail , sizeof tail , 1 , stream ); if (read_count == 1) { if (endian_flip) util_endian_flip_vector(&tail , sizeof tail , 1); if (tail == header) /* All OK */ status = FORTIO_OK; else if ( tail != header ) /* The numerical value of the tail did not agree with the header. */ status = FORTIO_HEADER_MISMATCH; } else /* The file ended before we could read the tail mark. */ status = FORTIO_MISSING_TAIL; } } *record_size = header; return status; }
bool ecl_kw_grdecl_fseek_next_kw( FILE * stream ) { long start_pos = util_ftell( stream ); long current_pos; char next_kw[256]; /* Determine if the current position of the file pointer is at the beginning of the line; if not skip the rest of the line; this is applies even though the tokens leading up this are not comments. */ { while (true) { char c; if (util_ftell(stream) == 0) /* We are at the very beginning of the file. Can just jump out of the loop. */ break; util_fseek( stream , -1 , SEEK_CUR ); c = fgetc( stream ); if (c == '\n') { /* We have walked backwards reaching the start of the line. We have not reached any !isspace() characters on the way and can go back to start_pos and read from there. */ util_fseek( stream , start_pos , SEEK_SET ); break; } if (!isspace( c )) { /* We hit a non-whitespace character; this means that start_pos was not at the start of the line. We skip the rest of this line, and then start reading on the next line. */ util_fskip_lines( stream , 1 ); break; } util_fseek( stream , -2 , SEEK_CUR ); } } while (true) { current_pos = util_ftell( stream ); if (fscanf(stream , "%s" , next_kw) == 1) { if ((next_kw[0] == next_kw[1]) && (next_kw[0] == ECL_COMMENT_CHAR)) // This is a comment line - skip it. util_fskip_lines( stream , 1 ); else { // This is a valid keyword i.e. a non-commented out string; return true. util_fseek( stream , current_pos , SEEK_SET ); return true; } } else { // EOF reached - return False. util_fseek( stream , start_pos , SEEK_SET ); return false; } } }
bool gen_kw_fload(gen_kw_type * gen_kw , const char * filename) { FILE * stream = util_fopen__( filename , "r"); if (stream) { const int size = gen_kw_config_get_data_size(gen_kw->config ); bool readOK = true; /* First try reading all the data as one long vector. */ { int index = 0; while ((index < size) && readOK) { double value; if (fscanf(stream,"%lg" , &value) == 1) gen_kw->data[index] = value; else readOK = false; index++; } } /* OK - rewind and try again with interlaced key + value pairs. Observe that we still require that ALL the elements in the gen_kw instance are set, i.e. it is not allowed to read only some of the keywords; but the ordering is not relevant. The code will be fooled (and give undefined erronous results) if the same key appears several times. Be polite! */ if (!readOK) { int counter = 0; readOK = true; util_fseek( stream , 0 , SEEK_SET ); while ((counter < size) && readOK) { char key[128]; double value; int fscanf_return = fscanf(stream , "%s %lg" , key , &value); if (fscanf_return == 2) { int index = gen_kw_config_get_index(gen_kw->config , key); if (index >= 0) gen_kw->data[index] = value; else util_abort("%s: key:%s not recognized as part of GEN_KW instance - error when reading file:%s \n",__func__ , key , filename); counter++; } else { util_abort("%s: failed to read (key,value) pair at line:%d in file:%s \n",__func__ , util_get_current_linenr( stream ) , filename); readOK = false; } } } if (!readOK) util_abort("%s: failed loading from file:%s \n",__func__ , filename); fclose(stream); return true; } else return false; }
void log_sync(log_type * logh) { #ifdef HAVE_FSYNC fsync( logh->fd ); #endif util_fseek( logh->stream , 0 , SEEK_END ); }
bool parser_fseek_string(const parser_type * parser , FILE * stream , const char * __string , bool skip_string, bool case_sensitive) { bool string_found = false; char * string = util_alloc_string_copy( __string ); if (!case_sensitive) util_strupr( string ); { long int initial_pos = util_ftell( stream ); /* Store the inital position. */ bool cont = true; if (strstr( string , parser->comment_start ) != NULL) util_abort("%s: sorry the string contains a comment start - will never find it ... \n"); /* A bit harsh ?? */ do { int c = fgetc( stream ); if (!case_sensitive) c = toupper( c ); /* Special treatment of quoters - does not properly handle escaping of the quoters. */ if (is_in_quoters( c , parser )) { long int quote_start_pos = util_ftell(stream); if (!fseek_quote_end( c , stream )) { util_fseek( stream , quote_start_pos , SEEK_SET); fprintf(stderr,"Warning: unterminated quotation starting at line: %d \n",util_get_current_linenr( stream )); util_fseek(stream , 0 , SEEK_END); } /* Now we are either at the first character following a terminated quotation, or at EOF. */ continue; } /* Special treatment of comments: */ if (c == parser->comment_start[0]) { /* OK - this might be the start of a comment - let us check further. */ bool comment_start = fgetc_while_equal( stream , &parser->comment_start[1] , false); if (comment_start) { long int comment_start_pos = util_ftell(stream) - strlen( parser->comment_start ); /* Start seeking for comment_end */ if (!util_fseek_string(stream , parser->comment_end , true , true)) { /* No end comment end was found - what to do about that?? The file is just positioned at the end - and the routine will exit at the next step - with a Warning. */ util_fseek( stream , comment_start_pos , SEEK_SET); fprintf(stderr,"Warning: unterminated comment starting at line: %d \n",util_get_current_linenr( stream )); util_fseek(stream , 0 , SEEK_END); } continue; /* Now we are at the character following a comment end - or at EOF. */ } } /*****************************************************************/ /* Now c is a regular character - and we can start looking for our string. */ if (c == string[0]) { /* OK - we got the first character right - lets try in more detail: */ bool equal = fgetc_while_equal( stream , &string[1] , case_sensitive); if (equal) { string_found = true; cont = false; } } if (c == EOF) cont = false; } while (cont); if (string_found) { if (!skip_string) { offset_type offset = (offset_type) strlen( string ); util_fseek(stream , -offset , SEEK_CUR); /* Reposition to the beginning of 'string' */ } } else util_fseek(stream , initial_pos , SEEK_SET); /* Could not find the string reposition at initial position. */ } free( string ); return string_found; }