code_c/Maasha/src/lib/filesys.c

   1 #include "common.h"
   2 #include "mem.h"
   3 #include "filesys.h"
   4
   5
   6 FILE *read_open( char *file )
   7 {
   8     /* Martin A. Hansen, November 2005 */
   9
  10     /* Unit test done. */
  11
  12     /* Given a file name, read-opens the file, */
  13     /* and returns a file pointer. */
  14
  15     FILE *fp;
  16
  17     if ( ( fp = fopen( file, "r" ) ) == NULL )
  18     {
  19         fprintf( stderr, "ERROR: Could not read-open file '%s': %s\n", file, strerror( errno ) );
  20         abort();
  21     }
  22
  23     return fp;
  24 }
  25
  26
  27 FILE *write_open( char *file )
  28 {
  29     /* Martin A. Hansen, November 2005 */
  30
  31     /* Unit test done. */
  32
  33     /* Given a file name, write-opens the file, */
  34     /* and returns a file pointer. */
  35
  36     FILE *fp;
  37
  38     if ( ( fp = fopen( file, "w" ) ) == NULL )
  39     {
  40         fprintf( stderr, "ERROR: Could not write-open file '%s': %s\n", file, strerror( errno ) );
  41         abort();
  42     }
  43
  44     return fp;
  45 }
  46
  47
  48 FILE *append_open( char *file )
  49 {
  50     /* Martin A. Hansen, November 2005 */
  51
  52     /* Unit test done. */
  53
  54     /* Given a file name, append-opens the file, */
  55     /* and returns a file pointer. */
  56
  57     FILE *fp;
  58
  59     if ( ( fp = fopen( file, "a" ) ) == NULL )
  60     {
  61         fprintf( stderr, "ERROR: Could not append-open file '%s': %s\n", file, strerror( errno ) );
  62         abort();
  63     }
  64
  65     return fp;
  66 }
  67
  68
  69 void close_stream( FILE *fp )
  70 {
  71     /* Martin A. Hansen, May 2008 */
  72
  73     /* Unit test done. */
  74
  75     /* Closes a stream or file associated with a given file pointer. */
  76
  77     if ( ( fclose( fp ) ) != 0 )
  78     {
  79         fprintf( stderr, "ERROR: Could not close stream: %s\n", strerror( errno ) );
  80         abort();
  81     }
  82 }
  83
  84
  85 char *file_read( FILE *fp, size_t len )
  86 {
  87     /* Martin A. Hansen, June 2008 */
  88
  89     /* Read in len number of bytes from the current position of a */
  90     /* file pointer into a string that is allocated and null terminated. */
  91
  92     char *string;
  93
  94     assert( len > 0 );
  95
  96     string = mem_get( len + 1 );
  97
  98     fread( string, len, 1, fp );
  99
 100     if ( ferror( fp ) != 0 )
 101     {
 102         fprintf( stderr, "ERROR: file_read failed\n" );
 103         abort();
 104     }
 105     else if ( feof( fp ) )
 106     {
 107         fprintf( stderr, "ERROR: file_read failed - end-of-file reached\n" );
 108
 109         abort();
 110     }
 111
 112     string[ len ] = '\0';
 113
 114     return string;
 115 }
 116
 117
 118 void file_unlink( char *file )
 119 {
 120     /* Martin A. Hansen, June 2008 */
 121
 122     /* Unit test done. */
 123
 124     /* Delete a file. */
 125
 126     if ( unlink( file ) == -1 )
 127     {
 128         fprintf( stderr, "ERROR: Could not unlink file '%s': %s\n", file, strerror( errno ) );
 129         abort();
 130     }
 131 }
 132
 133
 134 void file_rename( char *old_name, char *new_name )
 135 {
 136     /* Martin A. Hansen, June 2008 */
 137
 138     /* Unit test done. */
 139
 140     /* Rename a file. */
 141
 142     if ( rename( old_name, new_name ) != 0 )
 143     {
 144         fprintf( stderr, "ERROR: Could not rename file '%s' -> '%s': %s\n", old_name, new_name, strerror( errno ) );
 145
 146         abort();
 147     }
 148 }
 149
 150
 151 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FILE BUFFER <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 152
 153
 154 struct file_buffer *read_open_buffer( char *file )
 155 {
 156     /* Martin A. Hansen, June 2008 */
 157
 158     /* Opens a file for reading and loads a new buffer.*/
 159
 160     struct file_buffer *buffer;
 161     FILE               *fp;
 162     char               *str;
 163     bool                eof;
 164
 165     buffer = mem_get( sizeof( buffer ) );
 166
 167     fp  = read_open( file );
 168
 169     str = file_read( fp, FILE_BUFFER_SIZE );
 170
 171     feof( fp ) ? ( eof = TRUE ) : ( eof = FALSE );
 172
 173     buffer->fp   = fp;
 174     buffer->str  = str;
 175     buffer->pos  = 0;
 176     buffer->use  = 0;
 177     buffer->end  = strlen( str );
 178     buffer->size = FILE_BUFFER_SIZE;
 179     buffer->eof  = eof;
 180
 181     return buffer;
 182 }
 183
 184
 185 char buffer_getc( struct file_buffer *buffer )
 186 {
 187     /* Martin A. Hansen, June 2008 */
 188
 189     /* Get the next char from a file buffer, which is resized if necessary, until EOF.*/
 190
 191     while ( 1 )
 192     {
 193         if ( buffer->use == buffer->end )
 194         {
 195             if ( buffer->eof )
 196             {
 197                 return '\0';
 198             }
 199             else
 200             {
 201                 buffer->pos = buffer->use;
 202                 buffer_new_size( buffer, buffer->use );
 203                 buffer_resize( buffer );
 204             }
 205         }
 206
 207         return buffer->str[ buffer->use++ ];
 208     }
 209 }
 210
 211
 212 char *buffer_gets( struct file_buffer *buffer )
 213 {
 214     /* Martin A. Hansen, June 2008 */
 215
 216     /* Get the next line that is terminated by \n or EOF from a file buffer. */
 217
 218     char   *pt;
 219     char   *line;
 220     size_t  line_size;
 221
 222     while ( 1 )
 223     {
 224         if ( ( pt = memchr( &buffer->str[ buffer->use ], '\n', buffer->end - buffer->use ) ) != NULL )
 225         {
 226             line_size = pt - &buffer->str[ buffer->use ] + 1;
 227
 228             line = mem_get( line_size );
 229
 230             memcpy( line, &buffer->str[ buffer->use ], line_size );
 231
 232             line[ line_size ] = '\0';
 233
 234             buffer->use += line_size;
 235
 236             buffer_new_size( buffer, line_size );
 237
 238             return line;
 239         }
 240         else
 241         {
 242             if ( buffer->eof ) {
 243                 return NULL;
 244             } else {
 245                 buffer_resize( buffer );
 246             }
 247         }
 248     }
 249 }
 250
 251
 252 void buffer_new_size( struct file_buffer *buffer, int len )
 253 {
 254     /* Martin A. Hansen, June 2008 */
 255
 256     /* Increases buffer size until it is larger than len. */
 257
 258     while ( buffer->size < len )
 259     {
 260         buffer->size <<= 1;
 261
 262         if ( buffer->size <= 0 ) {
 263             die( "buffer_new_size failed." );
 264         }
 265     }
 266 }
 267
 268
 269 void buffer_resize( struct file_buffer *buffer )
 270 {
 271     /* Martin A. Hansen, June 2008 */
 272
 273     /* Resize file buffer. */
 274
 275     char   *str;
 276     size_t  str_len;
 277     size_t  new_end;
 278
 279     str = file_read( buffer->fp, buffer->size );
 280
 281     str_len = strlen( str );
 282
 283     feof( buffer->fp ) ? ( buffer->eof = TRUE ) : ( buffer->eof = FALSE );
 284
 285     if ( buffer->pos != 0 )
 286     {
 287         memmove( buffer->str, &buffer->str[ buffer->pos ], buffer->use - buffer->pos );
 288
 289         buffer->end -= buffer->pos;
 290         buffer->use  = 0;
 291         buffer->pos  = 0;
 292     }
 293
 294     new_end = buffer->end + str_len;
 295
 296     buffer->str = mem_resize( buffer->str, new_end + 1 );
 297
 298     memcpy( &buffer->str[ buffer->end ], str, str_len );
 299
 300     buffer->str[ new_end + 1 ] = '\0';
 301
 302     buffer->end = new_end;
 303
 304     mem_free( ( void * ) &str );
 305 }
 306
 307
 308 void buffer_destroy( struct file_buffer *buffer )
 309 {
 310     /* Martin A. Hansen, June 2008 */
 311
 312     /* Deallocates memory and close stream used by file buffer. */
 313
 314     close_stream( buffer->fp );
 315
 316     mem_free( ( void * ) &buffer->str );
 317     mem_free( ( void * ) &buffer );
 318 }
 319
 320
 321 void buffer_print( struct file_buffer *buffer )
 322 {
 323     /* Martin A. Hansen, June 2008 */
 324
 325     /* Debug function that prints the content of a file_buffer. */
 326
 327     printf( "buffer: {\n" );
 328     printf( "   pos    : %lu\n",    buffer->pos );
 329     printf( "   use    : %lu\n",    buffer->use );
 330     printf( "   end    : %lu\n",    buffer->end );
 331     printf( "   eof    : %d\n",     buffer->eof );
 332     printf( "   str    : ->%s<-\n", buffer->str );
 333     printf( "   str_len: %lu\n", strlen( buffer->str ) );
 334     printf( "}\n" );
 335 }
 336
 337
 338 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/