/Users/huttone/Devel/sedflux-new/sedflux/trunk/ew/utils/eh_io.c

Go to the documentation of this file.
00001 #include <eh_utils.h>
00002 
00003 #if G_BYTE_ORDER==G_LITTLE_ENDIAN
00004 
00005 gssize eh_fread_int32_from_be( const void *ptr , gssize size , gssize nitems , FILE* stream  )
00006 {
00007    gssize n = 0;
00008 
00009    eh_require( size==sizeof(gint32) );
00010 
00011    if ( ptr && stream )
00012    {
00013       gssize i;
00014       gint32 i_val;
00015 
00016       for ( i=0 ; i<nitems ; i++ )
00017       {
00018          n += fread( &i_val , sizeof(gint32) , 1 , stream );
00019          ((gint32*)ptr)[i] = GINT32_TO_BE( i_val );
00020       }
00021    }
00022 
00023    return n;
00024 }
00025 
00026 gssize eh_fread_int64_from_be( const void *ptr , gssize size , gssize nitems , FILE* stream  )
00027 {
00028    gssize n = 0;
00029 
00030    eh_require( size==sizeof(gint64) );
00031 
00032    if ( ptr && stream )
00033    {
00034       gssize i;
00035       gint64 i_val;
00036 
00037       for ( i=0 ; i<nitems ; i++ )
00038       {
00039          n += fread( &i_val , sizeof(gint64) , 1 , stream );
00040          ((gint64*)ptr)[i] = GINT64_TO_BE( i_val );
00041       }
00042    }
00043 
00044    return n;
00045 }
00046 
00047 gssize eh_fwrite_int32_to_be( const void *ptr , gssize size , gssize nitems , FILE* stream  )
00048 {
00049    gssize n = 0;
00050 
00051    eh_require( size==sizeof(gint32) );
00052 
00053    if ( ptr && stream )
00054    {
00055       gssize i;
00056       gint32 i_val;
00057 
00058       for ( i=0 ; i<nitems ; i++ )
00059       {
00060          i_val = GINT32_TO_BE( ((gint32*)(ptr))[i] );
00061          n += fwrite( &i_val , sizeof(gint32) , 1 , stream );
00062       }
00063    }
00064 
00065    return n;
00066 }
00067 
00068 gssize eh_fwrite_int64_to_be( const void *ptr , gssize size , gssize nitems , FILE* stream  )
00069 {
00070    gssize n = 0;
00071 
00072    eh_require( size==sizeof(gint64) );
00073 
00074    if ( ptr && stream )
00075    {
00076       gssize i;
00077       gint64 i_val;
00078 
00079       for ( i=0 ; i<nitems ; i++ )
00080       {
00081          i_val = GINT64_TO_BE( ((gint64*)(ptr))[i] );
00082          n += fwrite( &i_val , sizeof(gint64) , 1 , stream );
00083       }
00084    }
00085 
00086    return n;
00087 }
00088 
00089 #else
00090 
00091 
00092 gssize eh_fread_int32_from_le( const void *ptr , gssize size , gssize nitems , FILE* stream  )
00093 {
00094    gssize n = 0;
00095 
00096    eh_require( size==sizeof(gint32) );
00097 
00098    if ( ptr && stream )
00099    {
00100       gssize i;
00101       gint32 i_val;
00102 
00103       for ( i=0 ; i<nitems ; i++ )
00104       {
00105          n += fread( &i_val , sizeof(gint32) , 1 , stream );
00106          ((gint32*)ptr)[i] = GINT32_TO_LE( i_val );
00107       }
00108    }
00109 
00110    return n;
00111 }
00112 
00113 gssize eh_fread_int64_from_le( const void *ptr , gssize size , gssize nitems , FILE* stream  )
00114 {
00115    gssize n = 0;
00116 
00117    eh_require( size==sizeof(gint64) );
00118 
00119    if ( ptr && stream )
00120    {
00121       gssize i;
00122       gint64 i_val;
00123 
00124       for ( i=0 ; i<nitems ; i++ )
00125       {
00126          n += fread( &i_val , sizeof(gint64) , 1 , stream );
00127          ((gint64*)ptr)[i] = GINT64_TO_LE( i_val );
00128       }
00129    }
00130 
00131    return n;
00132 }
00133 
00134 gssize eh_fwrite_int32_to_le( const void *ptr , gssize size , gssize nitems , FILE* stream  )
00135 {
00136    gssize n = 0;
00137 
00138    eh_require( size==sizeof(gint32) );
00139 
00140    if ( ptr && stream )
00141    {
00142       gssize i;
00143       gint32 i_val;
00144 
00145       for ( i=0 ; i<nitems ; i++ )
00146       {
00147          i_val = GINT32_TO_LE( ((gint32*)(ptr))[i] );
00148          n += fwrite( &i_val , sizeof(gint32) , 1 , stream );
00149       }
00150    }
00151 
00152    return n;
00153 }
00154 
00155 gssize eh_fwrite_int64_to_le( const void *ptr , gssize size , gssize nitems , FILE* stream  )
00156 {
00157    gssize n = 0;
00158 
00159    eh_require( size==sizeof(gint64) );
00160 
00161    if ( ptr && stream )
00162    {
00163       gssize i;
00164       gint64 i_val;
00165 
00166       for ( i=0 ; i<nitems ; i++ )
00167       {
00168          i_val = GINT64_TO_LE( ((gint64*)(ptr))[i] );
00169          n += fwrite( &i_val , sizeof(gint64) , 1 , stream );
00170       }
00171    }
00172 
00173    return n;
00174 }
00175 
00176 #endif
00177 
00178 #ifndef HAVE_GETLINE
00179 # ifdef HAVE_FGETLN
00180 
00181 gssize
00182 getline( gchar** lineptr , gsize *n , FILE* stream )
00183 {
00184    gssize result = -1;
00185    gsize  len;
00186    gchar* s = fgetln( stream , &len );
00187 
00188    if ( s || feof(stream) )
00189    {
00190       if ( len+1>*n )
00191       {
00192          *lineptr = eh_renew( gchar* , *lineptr , len+1 );
00193          *n       = len+1;
00194       }
00195 
00196       memcpy( *lineptr , s , len );
00197       (*lineptr)[len] = '\0';
00198 
00199       if ( !feof(stream) )
00200          result   = len;
00201       else
00202          result   = -1;
00203    }
00204 
00205    return result;
00206 }
00207 # else /* don't have fgetln */
00208 gssize
00209 getline( gchar** lineptr , gsize *n , FILE* stream )
00210 {
00211    gssize result = -1;
00212 
00213    if ( *lineptr==NULL || *n==0 )
00214    {
00215       *n       = 120;
00216       *lineptr = eh_new( gchar , *n );
00217    }
00218 
00219    if ( *lineptr )
00220    {
00221       gchar* p;
00222       gchar* t     = NULL;
00223       gint   start = ftell( stream );
00224 
00225       p = fgets( *lineptr , *n-1 , stream ); /* Read in a block of characters */
00226       if ( p )
00227          t = (gchar*)memchr( p , '\n' , *n-1 ); /* Look for the delimiter */
00228 
00229       if ( !feof(stream) && !t ) /* Delimeter not found */
00230       {
00231          gint len = *n;
00232 
00233          for ( p+=len ; p && !t ; p+=120,len+=120 )
00234          {
00235             *lineptr  = eh_renew( gchar , *lineptr , len+120 ); /* Extend the length of the string */
00236             *n        = len+120;
00237             p         = fgets( p , 120 , stream ); /* Read the next block of bytes */
00238 
00239             if ( p )
00240                t = (gchar*)memchr( p , '\n' , 120 ); /* Look for the delimiter */
00241          }
00242       }
00243 
00244       if ( ferror(stream) || feof(stream) )
00245          result = -1;
00246       else
00247       {
00248          result = strlen( *lineptr );
00249          fseek( stream , start+result , SEEK_SET ); /* Move the file pointer to after the delimeter */
00250       }
00251    }
00252 
00253    return result;
00254 }
00255 # endif
00256 #endif /* don't have getline */
00257 
00258 
00259 #include <stdio.h>
00260 //#include <values.h>
00261 #include <string.h>
00262 
00263 #ifndef DATA_DELIMETER
00264 # define DATA_DELIMETER ":"
00265 #endif
00266 
00267 #ifndef TOKEN_DELIMETER 
00268 # define TOKEN_DELIMETER ","
00269 #endif
00270 
00271 #include <errno.h>
00272 
00273 gchar*
00274 eh_scan_str( FILE* fp , GError** error )
00275 {
00276    gchar* s = NULL;
00277 
00278    eh_require( fp );
00279    eh_return_val_if_fail( error==NULL || *error==NULL , NULL );
00280 
00281    if ( fp )
00282    {
00283       size_t  n;
00284       gchar*  s;
00285       GError* tmp_err = NULL;
00286 
00287       getline( &s , &n , fp );
00288 
00289       if ( s )
00290       {
00291          s    = g_memdup( s , n+1 );
00292          s[n] = '\0';
00293       }
00294       else if ( feof(fp) )
00295          s    = NULL;
00296       else
00297          eh_set_file_error_from_errno( &tmp_err , NULL , errno );
00298 
00299       if ( tmp_err ) g_propagate_error( error , tmp_err );
00300    }
00301 
00302    return s;
00303 }
00304 
00305 gchar**
00306 eh_scan_str_array( FILE* fp , gint* len , GError** error )
00307 {
00308    gchar** s_arr = NULL;
00309 
00310    eh_require( fp );
00311    eh_return_val_if_fail( error==NULL || *error==NULL , NULL );
00312 
00313    if ( fp )
00314    {
00315       gint    n;
00316       GError* tmp_err = NULL;
00317       gchar*  s       = eh_scan_str( fp , &tmp_err );
00318 
00319       if ( s )
00320       {
00321          s_arr = g_strsplit_set( s , ";," , -1 );
00322          n     = g_strv_length( s_arr );
00323 
00324          eh_free( s );
00325       }
00326       else if ( feof(fp) )
00327       {
00328          s_arr    = NULL;
00329          n        = 0;
00330       }
00331       else
00332          eh_set_file_error_from_errno( &tmp_err , NULL , errno );
00333 
00334       if ( tmp_err )
00335       {
00336          g_propagate_error( error , tmp_err );
00337          s_arr = NULL;
00338          n     = 0;
00339       }
00340 
00341       if ( len ) *len = n;
00342    }
00343 
00344    return s_arr;
00345 }
00346 
00347 gint*
00348 eh_scan_int_array( FILE* fp , gint* len , GError** error )
00349 {
00350    gint* i_arr = NULL;
00351 
00352    eh_require( fp );
00353    eh_return_val_if_fail( error==NULL || *error==NULL , NULL );
00354 
00355    if ( fp )
00356    {
00357       gint    n       = 0;
00358       GError* tmp_err = NULL;
00359       gchar** str_arr = eh_scan_str_array( fp , &n , &tmp_err );
00360 
00361       if ( str_arr )
00362       {
00363          gint i;
00364 
00365          n = g_strv_length( str_arr );
00366 
00367          i_arr = eh_new( gint , n );
00368 
00369          for ( i=0 ; i<n && !tmp_err ; i++ )
00370             i_arr[i] = eh_str_to_int( str_arr[i] , &tmp_err );
00371 
00372          g_strfreev( str_arr );
00373 
00374          if ( tmp_err )
00375          {
00376             eh_free( i_arr );
00377             i_arr = NULL;
00378             n     = 0;
00379          }
00380       }
00381 
00382       if ( tmp_err )
00383       {
00384          g_propagate_error( error , tmp_err );
00385          i_arr = NULL;
00386          n     = 0;
00387       }
00388 
00389       if ( len ) *len = n;
00390    }
00391 
00392    return i_arr;
00393 }
00394 
00395 double*
00396 eh_scan_dbl_array( FILE* fp , gint* len , GError** error )
00397 {
00398    double* d_arr = NULL;
00399 
00400    eh_require( fp );
00401    eh_return_val_if_fail( error==NULL || *error==NULL , NULL );
00402 
00403    if ( fp )
00404    {
00405       gint    n       = 0;
00406       GError* tmp_err = NULL;
00407       gchar** str_arr = eh_scan_str_array( fp , &n , &tmp_err );
00408 
00409       if ( str_arr )
00410       {
00411          gint i;
00412          n = g_strv_length( str_arr );
00413 
00414          d_arr = eh_new( double , n );
00415 
00416          for ( i=0 ; i<n && !tmp_err ; i++ )
00417             d_arr[i] = eh_str_to_dbl( str_arr[i] , &tmp_err );
00418 
00419          g_strfreev( str_arr );
00420 
00421          if ( tmp_err )
00422          {
00423             eh_free( d_arr );
00424             d_arr = NULL;
00425             n     = 0;
00426          }
00427       }
00428 
00429       if ( tmp_err )
00430       {
00431          g_propagate_error( error , tmp_err );
00432          d_arr = NULL;
00433          n     = 0;
00434       }
00435 
00436       if ( len ) *len = n;
00437    }
00438 
00439    return d_arr;
00440 }
00441 
00442 gboolean*
00443 eh_scan_boolean_array( FILE *fp , gint* len , GError** error )
00444 {
00445    gboolean* b_arr = NULL;
00446 
00447    eh_require( fp );
00448    eh_return_val_if_fail( error==NULL || *error==NULL , NULL );
00449 
00450    if ( fp )
00451    {
00452       gint    n       = 0;
00453       GError* tmp_err = NULL;
00454       gchar** str_arr = eh_scan_str_array( fp , &n , &tmp_err );
00455 
00456       if ( str_arr )
00457       {
00458          gint i;
00459          n = g_strv_length( str_arr );
00460 
00461          b_arr = eh_new( gboolean , n );
00462 
00463          for ( i=0 ; i<n && !tmp_err ; i++ )
00464             b_arr[i] = eh_str_to_boolean( str_arr[i] , &tmp_err );
00465 
00466          g_strfreev( str_arr );
00467 
00468          if ( tmp_err )
00469          {
00470             eh_free( b_arr );
00471             b_arr = NULL;
00472             n     = 0;
00473          }
00474       }
00475 
00476       if ( tmp_err )
00477       {
00478          g_propagate_error( error , tmp_err );
00479          b_arr = NULL;
00480          n     = 0;
00481       }
00482 
00483       if ( len ) *len = n;
00484    }
00485 
00486    return b_arr;
00487 }
00488 /*
00489 gint
00490 read_double_vector(FILE *fp,double *val,int len)
00491 {
00492    char **str_vec=NULL;
00493    gint i=0;
00494 
00495    str_vec=read_string_vector(fp,len);
00496    if ( str_vec )
00497       for (i=0;str_vec[i]!=NULL;i++)
00498          sscanf(str_vec[i],"%lf",&val[i]);
00499    g_strfreev( str_vec );
00500 
00501    return i;
00502 }
00503 
00504 gint
00505 read_time_vector( FILE *fp , double *val , int len )
00506 {
00507    char **str_vec=NULL;
00508    gint i=0;
00509 
00510    str_vec=read_string_vector(fp,len);
00511    if ( str_vec )
00512       for ( i=0 ; str_vec[i]!=NULL ; i++ )
00513          val[i] = eh_str_to_time_in_years( str_vec[i] );
00514    g_strfreev( str_vec );
00515    return i;
00516 }
00517 
00518 gint
00519 read_int_vector(FILE *fp,int *val,int len)
00520 {
00521    char **str_vec=NULL;
00522    gint i=0;
00523 
00524    str_vec=read_string_vector(fp,len);
00525    if ( str_vec )
00526       for (i=0;str_vec[i]!=NULL;i++)
00527          sscanf(str_vec[i],"%d",&(val[i]));
00528    g_strfreev( str_vec );
00529 
00530    return i;
00531 }
00532 
00533 #undef DATA_DELIMETER
00534 
00535 double **read_matrix(FILE *fp,int nColumns,int *nRows)
00536 {
00537    double **matrix=NULL;
00538    double *row;
00539    int i, j;
00540 
00541 //   row = (double*)malloc1D(sizeof(double)*nColumns);
00542    row = eh_new( double , nColumns );
00543 
00544    // See how many rows there will be.
00545    for (i=0; read_double_vector(fp,row,nColumns) ;i++);
00546    rewind(fp);
00547    *nRows = i;
00548 
00549 //   matrix = (double**)malloc2Ddouble(nColumns,*nRows);
00550    matrix = eh_new_2( double , nColumns , *nRows );
00551    for (i=0; read_double_vector(fp,row,nColumns) ;i++)
00552       for (j=0;j<nColumns;j++)
00553          matrix[j][i] = row[j];
00554 
00555    return matrix;
00556 }
00557 
00558 #include <string.h>
00559 
00560 gboolean
00561 read_logical_value( FILE *fp )
00562 {
00563    char str[S_LINEMAX];
00564    read_string_value(fp,str);
00565    eh_str_trim_left(eh_str_trim_right(str));
00566    if (    g_ascii_strcasecmp( str , "ON"  ) == 0
00567         || g_ascii_strcasecmp( str , "YES" ) == 0 )
00568       return TRUE;
00569    if (    g_ascii_strcasecmp( str , "OFF" ) == 0
00570         || g_ascii_strcasecmp( str , "NO"  ) == 0 )
00571       return FALSE;
00572    else
00573    {
00574       eh_info( "read_logical_value: unknown flag -- %s\n" , str );
00575       eh_info( "read_logical_value: valid options are: 'ON', or 'OFF'.\n");
00576       eh_exit(-1);
00577    }
00578 
00579    eh_require_not_reached();
00580    return FALSE;
00581 
00582 }
00583 
00584 */
00585 void
00586 eh_print_msg( int msg_level , char *function_name , char *msg )
00587 {
00588 
00589    g_strchomp( msg );
00590 
00591    switch ( msg_level )
00592    {
00593       case 0:
00594          break;
00595       case 1:
00596          fprintf( stderr , "%s: %s: %s\n" , "warning" , function_name , msg );
00597          break;
00598       case 2:
00599          fprintf( stderr , "%s: %s: %s\n" , "error" , function_name , msg );
00600          fprintf( stderr , "quitting...\n" );
00601          eh_exit(-1);
00602    }
00603 
00604 }
00605 
00606 char *eh_input_str( char *msg , char *default_str )
00607 {
00608    char *str = eh_new( char , S_LINEMAX );
00609 
00610    //---
00611    // Print the message followed by the default string in [].
00612    //---
00613    fprintf( stderr , "%s " , msg );
00614    if ( default_str )
00615       fprintf( stderr , "[%s] " , default_str );
00616    fprintf( stderr , ": " );
00617 
00618    //---   
00619    // Read a line of input.  If the line is blank, use the default string.
00620    // Remove leading and trailing whitespace from the string.
00621    //---
00622    fgets( str , S_LINEMAX , stdin );
00623    if ( default_str && strncmp( str , "\n" , 1 )==0 )
00624       strcpy( str , default_str );
00625    g_strstrip( str );
00626 
00627    return str;
00628 }
00629 
00630 gboolean
00631 eh_input_boolean( char *msg , gboolean default_val )
00632 {
00633    char *str = eh_new( char , S_LINEMAX );
00634    gboolean ans, valid_ans = FALSE;
00635 
00636    while ( !valid_ans )
00637    {
00638       fprintf( stderr , "%s [%s]: " , msg , (default_val)?"yes":"no" );
00639    
00640       fgets( str , S_LINEMAX , stdin );
00641 
00642       if ( g_ascii_strncasecmp( str , "\n" , 1 ) == 0 )
00643       {
00644          ans = default_val;
00645          valid_ans = TRUE;
00646       }
00647       else if (    g_ascii_strncasecmp( str , "YES" , 2 )==0
00648                 || g_ascii_strncasecmp( str , "Y"   , 1 )==0 )
00649       {
00650          ans = TRUE;
00651          valid_ans = TRUE;
00652       }
00653       else if (    g_ascii_strncasecmp( str , "NO" , 2 )==0 
00654                 || g_ascii_strncasecmp( str , "N"  , 1 )==0 )
00655       {  
00656          ans = FALSE;
00657          valid_ans = TRUE;
00658       }
00659    }
00660 
00661    eh_free( str );
00662 
00663    return ans;
00664 }
00665 
00666 gchar*
00667 eh_get_input_val( FILE *fp , char *msg , char *default_str )
00668 {
00669    char *str = eh_new( char , S_LINEMAX );
00670 
00671    fprintf( stderr , "%s " , msg );
00672    if ( default_str )
00673       fprintf( stderr , "[%s] " , default_str );
00674    fprintf( stderr , ": " );
00675 
00676    fgets( str , S_LINEMAX , fp );
00677    if ( default_str && strncmp( str , "\n" , 1 )==0 )
00678       strcpy( str , default_str );
00679    g_strstrip( str );
00680    return str;
00681 }

Generated on Fri Jan 4 18:04:16 2008 for sedflux by  doxygen 1.5.2