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
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 );
00226 if ( p )
00227 t = (gchar*)memchr( p , '\n' , *n-1 );
00228
00229 if ( !feof(stream) && !t )
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 );
00236 *n = len+120;
00237 p = fgets( p , 120 , stream );
00238
00239 if ( p )
00240 t = (gchar*)memchr( p , '\n' , 120 );
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 );
00250 }
00251 }
00252
00253 return result;
00254 }
00255 # endif
00256 #endif
00257
00258
00259 #include <stdio.h>
00260
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
00490
00491
00492
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531
00532
00533
00534
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
00563
00564
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580
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
00612
00613 fprintf( stderr , "%s " , msg );
00614 if ( default_str )
00615 fprintf( stderr , "[%s] " , default_str );
00616 fprintf( stderr , ": " );
00617
00618
00619
00620
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 }