g_src/files.cpp

   1 #include "platform.h"
   2 #include <cerrno>
   3 #include <string>
   4 #include <cstring>
   5 #include <cmath>
   6 #include <iostream>
   7 #include <sstream>
   8 #include <fstream>
   9 #include <algorithm>
  10 #include <map>
  11 #include <set>
  12 #include <stdio.h>
  13 //#include <unistd.h>
  14
  15 extern "C" {
  16 #include <zlib.h>
  17 #ifndef WIN32
  18 # include <sys/types.h>
  19 # include <sys/stat.h>
  20 # include <sys/time.h>
  21 # include <signal.h>
  22 #endif
  23 }
  24 #include "svector.h"
  25
  26 #ifdef WIN32
  27
  28 #ifndef INTEGER_TYPES
  29         #define INTEGER_TYPES
  30         typedef short int16_t;
  31         typedef int int32_t;
  32         typedef long long int64_t;
  33         typedef unsigned short uint16_t;
  34         typedef unsigned int uint32_t;
  35         typedef unsigned long long uint64_t;
  36 #endif
  37
  38 typedef int32_t VIndex;
  39 typedef int32_t Ordinal;
  40
  41 #endif
  42
  43 #include "random.h"
  44
  45 using std::string;
  46
  47 #include "basics.h"
  48 #include "endian.h"
  49 #include "files.h"
  50 #include "enabler.h"
  51 #include "find_files.h"
  52
  53 inline void CHECK_ERR(int err, const char* msg)
  54 {
  55         if (err != Z_OK)
  56                 {
  57                 MessageBox(NULL, "One of the compressed files on disk has errors in it.  Restore from backup if you are able.", 0, 0);
  58                 exit(1);
  59                 }
  60 }
  61
  62 using std::fstream;
  63
  64 char file_compressorst::def_ibuff[FILE_IN_BUFF];
  65 char file_compressorst::def_obuff[FILE_OUT_BUFF];
  66
  67 char file_compressorst::load_posnull_pointer()
  68 {
  69         char dummy;
  70         read_file(dummy);
  71
  72         if(!dummy)return 0;
  73         else return 1;
  74 }
  75
  76 char file_compressorst::save_posnull_pointer(void *ptr)
  77 {
  78         char dummy;
  79
  80         if(ptr==NULL)
  81                 {
  82                 dummy=0;
  83                 write_file(dummy);
  84                 return 0;
  85                 }
  86         else
  87                 {
  88                 dummy=1;
  89                 write_file(dummy);
  90                 return 1;
  91                 }
  92 }
  93
  94 char file_compressorst::write_file(string &str)
  95 {
  96         short ln=str.length();
  97         if(ln>=10000||ln<0)ln=0;
  98
  99         if(!write_file(ln))return 0;
 100
 101         if(ln==0)return 1;
 102
 103         if(!write_file((void *)str.c_str(),sizeof(char)*ln))return 0;
 104
 105         return 1;
 106 }
 107
 108 char file_compressorst::read_file(string &str)
 109 {
 110         str.erase();
 111
 112         short ln;
 113
 114         if(!read_file(ln))return 0;
 115
 116         if(ln==0)return 1;
 117
 118         char *strar=new char[ln+1];
 119
 120         if(!read_file(strar,sizeof(char)*ln))
 121                 {
 122                 delete[] strar;
 123                 return 0;
 124                 }
 125         strar[ln]='\x0';
 126
 127         str=strar;
 128
 129         delete[] strar;
 130         return 1;
 131 }
 132
 133 char file_compressorst::write_file(void *write_var,long write_size)
 134 {
 135         if (!f.is_open())return 0;
 136
 137         if(!compressed)
 138                 {
 139                 f.write((char *)write_var,write_size);
 140                 return 1;
 141                 }
 142
 143         //WRITE OUT THE VARIABLE CHUNK BY CHUNK
 144         while(write_size>0)
 145                 {
 146                 //FLUSH THE BUFFER IF NECESSARY
 147                 if(in_buffer_amount_loaded>=in_buffersize)
 148                         {
 149                         if(!flush_in_buffer())return 0;
 150                         }
 151
 152                 //SET THE AMOUNT TO COPY
 153                 long copy_size=in_buffersize-in_buffer_amount_loaded;
 154                 if(write_size<copy_size)copy_size=write_size;
 155
 156                 //COPY THE NEXT CHUNK INTO THE BUFFER
 157                 memmove(in_buffer+in_buffer_amount_loaded,write_var,copy_size);
 158
 159                 write_var=((char *)write_var) + copy_size;
 160                 write_size-=copy_size;
 161                 in_buffer_amount_loaded+=copy_size;
 162                 }
 163
 164         return 1;
 165 }
 166
 167 char file_compressorst::flush_in_buffer()
 168 {
 169         if (!f.is_open())return 0;
 170         if(!compressed)return 1;
 171         if(in_buffer_amount_loaded==0)return 1;//EXTRA CALLS TO FLUSH SHOULDN'T KILL YOU
 172
 173         //TARN: adapted from zlib example files
 174
 175         //SET UP THE COMPRESSOR
 176         z_stream c_stream;
 177         int err;
 178
 179         c_stream.zalloc = (alloc_func)0;
 180         c_stream.zfree = (free_func)0;
 181         c_stream.opaque = (voidpf)0;
 182
 183         err = deflateInit(&c_stream, 9);
 184         CHECK_ERR(err, "deflateInit");
 185
 186         c_stream.next_out = (Bytef*)out_buffer;
 187         c_stream.avail_out = out_buffersize;
 188
 189         //SEND IT TO THE COMPRESSOR
 190         c_stream.next_in = (Bytef*)in_buffer;
 191         c_stream.avail_in = in_buffer_amount_loaded;
 192
 193         while (c_stream.total_in != in_buffer_amount_loaded && c_stream.total_out < out_buffersize)
 194                 {
 195                 err = deflate(&c_stream, Z_NO_FLUSH);
 196                 CHECK_ERR(err, "deflate");
 197                 }
 198
 199         //FINISH UP THE STREAM
 200         while(1)
 201                 {
 202                 err = deflate(&c_stream, Z_FINISH);
 203                 if (err == Z_STREAM_END) break;
 204                 CHECK_ERR(err, "deflate");
 205                 }
 206
 207         err = deflateEnd(&c_stream);
 208         CHECK_ERR(err, "deflateEnd");
 209
 210         //SAVE THE COMPRESSED BIT AS A GIANT BLOCK
 211         if(c_stream.total_out>0)
 212                 {
 213                 long compsize=byteswap((long)(c_stream.total_out));
 214
 215                 //WRITE IT
 216                 f.write((char*)&compsize,sizeof(long));
 217                 f.write(out_buffer,c_stream.total_out);
 218                 }
 219
 220         in_buffer_position=0;
 221         in_buffer_amount_loaded=0;
 222
 223         return 1;
 224 }
 225
 226 char file_compressorst::read_file(void *read_var,long read_size)
 227 {
 228         if (!f.is_open())return 0;
 229
 230         if(!compressed)
 231                 {
 232                 f.read((char *)read_var,read_size);
 233                 return 1;
 234                 }
 235
 236         //NOW LOAD INTO read_var UNTIL DONE
 237         while(read_size>0)
 238                 {
 239                 //GET A BUFFER IF NECESSARY
 240                 if(in_buffer_amount_loaded==0||
 241                         in_buffer_position>=in_buffer_amount_loaded)
 242                         {
 243                         if(!load_new_in_buffer())return 0;
 244                         }
 245
 246                 //BAIL IF STILL NO BUFFER LEFT
 247                 if(in_buffer_amount_loaded==0)return 0;
 248
 249                 //SET THE AMOUNT TO COPY
 250                 long copy_size=in_buffer_amount_loaded-in_buffer_position;
 251                 if(read_size<copy_size)copy_size=read_size;
 252
 253                 //COPY
 254                 memmove(read_var,in_buffer+in_buffer_position,copy_size);
 255
 256                 read_var=((char *)read_var) + copy_size;
 257                 read_size-=copy_size;
 258                 in_buffer_position+=copy_size;
 259                 }
 260
 261         return 1;
 262 }
 263
 264 char file_compressorst::load_new_in_buffer()
 265 {
 266         if (!f.is_open())return 0;
 267         if(!compressed)return 1;
 268
 269         in_buffer_position=0;
 270         in_buffer_amount_loaded=0;
 271
 272         //LOAD THE BLOCK OF COMPRESSED DATA
 273         f.read((char*)&out_buffer_amount_written,sizeof(long));
 274         out_buffer_amount_written=byteswap(out_buffer_amount_written);
 275         f.read(out_buffer,out_buffer_amount_written);
 276
 277         int err;
 278
 279         if(out_buffer_amount_written>0)
 280                 {
 281                 //TARN: adapted from zlib example files
 282
 283                 //UNCOMPRESS
 284                 z_stream d_stream; // decompression stream
 285
 286                 d_stream.zalloc = (alloc_func)0;
 287                 d_stream.zfree = (free_func)0;
 288                 d_stream.opaque = (voidpf)0;
 289
 290                 d_stream.next_in  = (Bytef*)out_buffer;
 291                 d_stream.avail_in = out_buffer_amount_written;
 292
 293                 err = inflateInit(&d_stream);
 294                 CHECK_ERR(err, "inflateInit");
 295
 296                 d_stream.next_out = (Bytef*)in_buffer;
 297                 d_stream.avail_out = in_buffersize;
 298
 299                 while (d_stream.total_out < in_buffersize && d_stream.total_in < out_buffer_amount_written)
 300                         {
 301                         //d_stream.avail_in = d_stream.avail_out = 1; // force small buffers
 302                         err = inflate(&d_stream, Z_NO_FLUSH);
 303
 304                         if (err == Z_STREAM_END) break;
 305                         CHECK_ERR(err, "inflate");
 306                         }
 307
 308                 err = inflateEnd(&d_stream);
 309                 CHECK_ERR(err, "inflateEnd");
 310
 311                 in_buffer_amount_loaded=d_stream.total_out;
 312
 313                 return 1;
 314                 }
 315         else return 0;
 316 }
 317
 318 void file_compressorst::close_file()
 319 {
 320         if (f.is_open())
 321                 {
 322                 f.close();
 323                 }
 324 }
 325
 326 char file_compressorst::open_file(const string &filename,char existing_only)
 327 {
 328         if(filename.empty())return 0;
 329
 330         //RESET DATA
 331         in_buffer_amount_loaded=0;
 332         in_buffer_position=0;
 333         out_buffer_amount_written=0;
 334
 335 /*
 336         //CHECK IF FILE ALREADY EXISTS
 337         f.open(filename.c_str(), fstream::in);
 338         char file_exists = f.is_open();
 339         if (file_exists)f.close();
 340
 341         //OPEN FILE
 342         if(!existing_only || file_exists)
 343                 f.open(filename.c_str(), fstream::in | fstream::out | fstream::binary);
 344         else
 345                 f.open(filename.c_str(), fstream::in | fstream::out | fstream::binary);
 346 */
 347         //if(existing_only)h=CreateFile(filename.c_str(),GENERIC_READ|GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
 348         //else h=CreateFile(filename.c_str(),GENERIC_READ|GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
 349
 350         if(f.is_open())f.close();
 351         f.clear();
 352
 353         if(existing_only)
 354                 f.open(filename.c_str(), fstream::in | fstream::out | fstream::binary);
 355         else
 356                 f.open(filename.c_str(), fstream::in | fstream::out | fstream::binary | fstream::trunc);
 357
 358         if (f.is_open())return 1;
 359         else return 0;
 360 }
 361
 362 file_compressorst::file_compressorst(char *new_in_buffer,long new_in_buffersize,
 363                                                                          char *new_out_buffer,long new_out_buffersize)
 364 {
 365         compressed=true;
 366
 367         in_buffer=new_in_buffer;
 368         in_buffersize=new_in_buffersize;
 369         in_buffer_amount_loaded=0;
 370         in_buffer_position=0;
 371
 372         out_buffer=new_out_buffer;
 373         out_buffersize=new_out_buffersize;
 374         out_buffer_amount_written=0;
 375
 376         f.clear();
 377 }
 378
 379 file_compressorst::file_compressorst()
 380 {
 381         compressed=true;
 382
 383         in_buffer=def_ibuff;
 384         in_buffersize=FILE_IN_BUFF;
 385         in_buffer_amount_loaded=0;
 386         in_buffer_position=0;
 387
 388         out_buffer=def_obuff;
 389         out_buffersize=FILE_OUT_BUFF;
 390         out_buffer_amount_written=0;
 391
 392         f.clear();
 393 }
 394
 395 void copy_file(const string &src,const string &dst)
 396 {
 397         std::ifstream in_stream(src.c_str(),std::ios_base::binary);
 398         std::ofstream out_stream(dst.c_str(),std::ios_base::binary);
 399         if(in_stream.is_open()&&out_stream.is_open())
 400                 {
 401                 out_stream<<in_stream.rdbuf();
 402                 }
 403         in_stream.close();
 404         out_stream.close();
 405 }
 406
 407 void replace_file(const string &src, const string &dst) {
 408 #ifdef WIN32
 409   remove(dst.c_str());
 410 #endif
 411   rename(src.c_str(), dst.c_str());
 412 }