code_c/Maasha/src/lib/filesys.c

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