Fixed up warnings

Frameworks/File_Extractor/File_Extractor/7z_C/7z.h

@@ -175,7 +175,7 @@ size_t SzArEx_GetFileNameUtf16(const CSzArEx *p, size_t fileIndex, UInt16 *dest)
 SRes SzArEx_Extract(
     const CSzArEx *db,
     ILookInStream *inStream,
-    UInt32 fileIndex,         /* index of file */
+    UInt64 fileIndex,         /* index of file */
     UInt32 *blockIndex,       /* index of solid block */
     Byte **outBuffer,         /* pointer to pointer to output buffer (allocated with allocMain) */
     size_t *outBufferSize,    /* buffer size for output buffer */

Frameworks/File_Extractor/File_Extractor/7z_C/7zIn.c

@@ -1322,7 +1322,7 @@ SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream, ISzAlloc *allocMain, ISzAl
 SRes SzArEx_Extract(
     const CSzArEx *p,
     ILookInStream *inStream,
-    UInt32 fileIndex,
+    UInt64 fileIndex,
     UInt32 *blockIndex,
     Byte **outBuffer,
     size_t *outBufferSize,

Frameworks/File_Extractor/File_Extractor/7z_C/LzFindMt.c

@@ -97,7 +97,7 @@ void MtSync_Destruct(CMtSync *p)
 
 #define RINOK_THREAD(x) { if ((x) != 0) return SZ_ERROR_THREAD; }
 
-static SRes MtSync_Create2(CMtSync *p, unsigned (MY_STD_CALL *startAddress)(void *), void *obj, UInt32 numBlocks)
+static SRes MtSync_Create2(CMtSync *p, THREAD_FUNC_RET_TYPE (MY_STD_CALL *startAddress)(void *), void *obj, UInt32 numBlocks)
 {
   if (p->wasCreated)
     return SZ_OK;
@@ -119,7 +119,7 @@ static SRes MtSync_Create2(CMtSync *p, unsigned (MY_STD_CALL *startAddress)(void
   return SZ_OK;
 }
 
-static SRes MtSync_Create(CMtSync *p, unsigned (MY_STD_CALL *startAddress)(void *), void *obj, UInt32 numBlocks)
+static SRes MtSync_Create(CMtSync *p, THREAD_FUNC_RET_TYPE (MY_STD_CALL *startAddress)(void *), void *obj, UInt32 numBlocks)
 {
   SRes res = MtSync_Create2(p, startAddress, obj, numBlocks);
   if (res != SZ_OK)
@@ -451,8 +451,8 @@ void MatchFinderMt_Destruct(CMatchFinderMt *p, ISzAlloc *alloc)
 #define kHashBufferSize (kMtHashBlockSize * kMtHashNumBlocks)
 #define kBtBufferSize (kMtBtBlockSize * kMtBtNumBlocks)
 
-static unsigned MY_STD_CALL HashThreadFunc2(void *p) { HashThreadFunc((CMatchFinderMt *)p);  return 0; }
+static THREAD_FUNC_RET_TYPE MY_STD_CALL HashThreadFunc2(void *p) { HashThreadFunc((CMatchFinderMt *)p);  return 0; }
-static unsigned MY_STD_CALL BtThreadFunc2(void *p)
+static THREAD_FUNC_RET_TYPE MY_STD_CALL BtThreadFunc2(void *p)
 {
   Byte allocaDummy[0x180];
   int i = 0;

Frameworks/File_Extractor/File_Extractor/7z_C/MtCoder.c

@@ -25,12 +25,12 @@ static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE LoopThreadFunc(void *pp)
   for (;;)
   {
     if (Event_Wait(&p->startEvent) != 0)
-      return SZ_ERROR_THREAD;
+      return (THREAD_FUNC_RET_TYPE) SZ_ERROR_THREAD;
     if (p->stop)
       return 0;
     p->res = p->func(p->param);
     if (Event_Set(&p->finishedEvent) != 0)
-      return SZ_ERROR_THREAD;
+      return (THREAD_FUNC_RET_TYPE) SZ_ERROR_THREAD;
   }
 }
 
@@ -239,7 +239,7 @@ static THREAD_FUNC_RET_TYPE THREAD_FUNC_CALL_TYPE ThreadFunc(void *pp)
       next->stopWriting = True;
       Event_Set(&next->canRead);
       Event_Set(&next->canWrite);
-      return res;
+      return (THREAD_FUNC_RET_TYPE) (long) res;
     }
     if (stop)
       return 0;

Frameworks/File_Extractor/File_Extractor/fex/Binary_Extractor.cpp

@@ -71,7 +71,7 @@ blargg_err_t Binary_Extractor::stat_v()
 	return open_v();
 }
 
-blargg_err_t Binary_Extractor::extract_v( void* p, int n )
+blargg_err_t Binary_Extractor::extract_v( void* p, long n )
 {
 	return arc().read( p, n );
 }

Frameworks/File_Extractor/File_Extractor/fex/Binary_Extractor.h

@@ -20,7 +20,7 @@ protected:
 	virtual blargg_err_t rewind_v();
 
 	virtual blargg_err_t stat_v();
-	virtual blargg_err_t extract_v( void*, int );
+	virtual blargg_err_t extract_v( void*, long );
 };
 
 #endif

Frameworks/File_Extractor/File_Extractor/fex/Data_Reader.cpp

@@ -21,7 +21,7 @@ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
 
 // Data_Reader
 
-blargg_err_t Data_Reader::read( void* p, int n )
+blargg_err_t Data_Reader::read( void* p, long n )
 {
 	assert( n >= 0 );
 	
@@ -45,7 +45,7 @@ blargg_err_t Data_Reader::read_avail( void* p, int* n_ )
 {
 	assert( *n_ >= 0 );
 	
-	int n = min( (BOOST::uint64_t)(*n_), remain() );
+	long n = min( (BOOST::uint64_t)(*n_), remain() );
 	*n_ = 0;
 	
 	if ( n < 0 )
@@ -58,7 +58,7 @@ blargg_err_t Data_Reader::read_avail( void* p, int* n_ )
 	if ( !err )
 	{
 		remain_ -= n;
-		*n_ = n;
+		*n_ = (int) n;
 	}
 	
 	return err;
@@ -72,19 +72,19 @@ blargg_err_t Data_Reader::read_avail( void* p, long* n )
 	return err;
 }
 
-blargg_err_t Data_Reader::skip_v( int count )
+blargg_err_t Data_Reader::skip_v( BOOST::uint64_t count )
 {
 	char buf [512];
 	while ( count )
 	{
-		int n = min( count, (int) sizeof buf );
+        BOOST::uint64_t n = min( count, (BOOST::uint64_t) sizeof buf );
 		count -= n;
 		RETURN_ERR( read_v( buf, n ) );
 	}
 	return blargg_ok;
 }
 
-blargg_err_t Data_Reader::skip( int n )
+blargg_err_t Data_Reader::skip( long n )
 {
 	assert( n >= 0 );
 	
@@ -111,9 +111,6 @@ blargg_err_t File_Reader::seek( BOOST::uint64_t n )
 {
 	assert( n >= 0 );
 	
-	if ( n < 0 )
-		return blargg_err_caller;
-	
 	if ( n == tell() )
 		return blargg_ok;
 	
@@ -141,7 +138,7 @@ Subset_Reader::Subset_Reader( Data_Reader* dr, BOOST::uint64_t size ) :
 	set_remain( min( size, dr->remain() ) );
 }
 
-blargg_err_t Subset_Reader::read_v( void* p, int s )
+blargg_err_t Subset_Reader::read_v( void* p, long s )
 {
 	return in->read( p, s );
 }
@@ -158,9 +155,9 @@ Remaining_Reader::Remaining_Reader( void const* h, int size, Data_Reader* r ) :
 	set_remain( size + r->remain() );
 }
 
-blargg_err_t Remaining_Reader::read_v( void* out, int count )
+blargg_err_t Remaining_Reader::read_v( void* out, long count )
 {
-	int first = min( count, header_remain );
+	long first = min( count, header_remain );
 	if ( first )
 	{
 		memcpy( out, header, first );
@@ -180,13 +177,13 @@ Mem_File_Reader::Mem_File_Reader( const void* p, long s ) :
 	set_size( s );
 }
 
-blargg_err_t Mem_File_Reader::read_v( void* p, int s )
+blargg_err_t Mem_File_Reader::read_v( void* p, long s )
 {
 	memcpy( p, begin + tell(), s );
 	return blargg_ok;
 }
 
-blargg_err_t Mem_File_Reader::seek_v( int )
+blargg_err_t Mem_File_Reader::seek_v( BOOST::uint64_t )
 {
 	return blargg_ok;
 }
@@ -201,7 +198,7 @@ Callback_Reader::Callback_Reader( callback_t c, BOOST::uint64_t s, void* d ) :
 	set_remain( s );
 }
 
-blargg_err_t Callback_Reader::read_v( void* out, int count )
+blargg_err_t Callback_Reader::read_v( void* out, long count )
 {
 	return callback( user_data, out, count );
 }
@@ -216,12 +213,12 @@ Callback_File_Reader::Callback_File_Reader( callback_t c, BOOST::uint64_t s, voi
 	set_size( s );
 }
 
-blargg_err_t Callback_File_Reader::read_v( void* out, int count )
+blargg_err_t Callback_File_Reader::read_v( void* out, long count )
 {
 	return callback( user_data, out, count, tell() );
 }
 
-blargg_err_t Callback_File_Reader::seek_v( int )
+blargg_err_t Callback_File_Reader::seek_v( BOOST::uint64_t )
 {
 	return blargg_ok;
 }
@@ -232,8 +229,6 @@ static const BOOST::uint8_t val_tab[6]={0,0xC0,0xE0,0xF0,0xF8,0xFC};
 
 size_t utf8_char_len_from_header( char p_c )
 {
-	BOOST::uint8_t c = (BOOST::uint8_t)p_c;
-
 	size_t cnt = 0;
 	for(;;)
 	{
@@ -599,13 +594,21 @@ blargg_err_t Std_File_Reader::open( const char path [] )
 
 void Std_File_Reader::make_unbuffered()
 {
-    long offset = ftell( STATIC_CAST(FILE*, file_) );
+#ifdef _WIN32
+    BOOST::uint64_t offset = _ftelli64( STATIC_CAST(FILE*, file_) );
+#else
+    BOOST::uint64_t offset = ftello( STATIC_CAST(FILE*, file_) );
+#endif
 	if ( setvbuf( STATIC_CAST(FILE*, file_), NULL, _IONBF, 0 ) )
 		check( false ); // shouldn't fail, but OK if it does
-    fseek( STATIC_CAST(FILE*, file_), offset, SEEK_SET );
+#ifdef _WIN32
+    _fseeki64( STATIC_CAST(FILE*, file_), offset, SEEK_SET );
+#else
+    fseeko( STATIC_CAST(FILE*, file_), offset, SEEK_SET );
+#endif
 }
 
-blargg_err_t Std_File_Reader::read_v( void* p, int s )
+blargg_err_t Std_File_Reader::read_v( void* p, long s )
 {
 	if ( (size_t) s != fread( p, 1, s, STATIC_CAST(FILE*, file_) ) )
 	{
@@ -731,21 +734,27 @@ static blargg_err_t convert_gz_error( gzFile file )
 	return blargg_err_internal;
 }
 
-blargg_err_t Gzip_File_Reader::read_v( void* p, int s )
+blargg_err_t Gzip_File_Reader::read_v( void* p, long s )
 {
-    int result = gzread( (gzFile) file_, p, s );
+    while ( s > 0 )
-	if ( result != s )
+    {
-	{
+        int s_i = (int)( s > INT_MAX ? INT_MAX : s );
-		if ( result < 0 )
+        int result = gzread( (gzFile) file_, p, s_i );
-            return convert_gz_error( (gzFile) file_ );
+        if ( result != s_i )
+        {
+            if ( result < 0 )
+                return convert_gz_error( (gzFile) file_ );
 		
-		return blargg_err_file_corrupt;
+            return blargg_err_file_corrupt;
-	}
+        }
+        p = (char*)p + result;
+        s -= result;
+    }
 	
 	return blargg_ok;
 }
 
-blargg_err_t Gzip_File_Reader::seek_v( int n )
+blargg_err_t Gzip_File_Reader::seek_v( BOOST::uint64_t n )
 {
     if ( gzseek( (gzFile) file_, n, SEEK_SET ) < 0 )
         return convert_gz_error( (gzFile) file_ );

Frameworks/File_Extractor/File_Extractor/fex/Data_Reader.h

@@ -26,13 +26,13 @@ public:
 
 	// Reads exactly n bytes, or returns error if they couldn't ALL be read.
 	// Reading past end of file results in blargg_err_file_eof.
-	blargg_err_t read( void* p, int n );
+	blargg_err_t read( void* p, long n );
 
 	// Number of bytes remaining until end of file
 	BOOST::uint64_t remain() const                              { return remain_; }
 
 	// Reads and discards n bytes. Skipping past end of file results in blargg_err_file_eof.
-	blargg_err_t skip( int n );
+	blargg_err_t skip( long n );
 	
 	virtual ~Data_Reader() { }
 
@@ -50,12 +50,12 @@ protected:
 	
 	// Do same as read(). Guaranteed that 0 < n <= remain(). Value of remain() is updated
 	// AFTER this call succeeds, not before. set_remain() should NOT be called from this.
-	virtual blargg_err_t read_v( void*, int n )     BLARGG_PURE( { (void)n; return blargg_ok; } )
+	virtual blargg_err_t read_v( void*, long n )     BLARGG_PURE( { (void)n; return blargg_ok; } )
 	
 	// Do same as skip(). Guaranteed that 0 < n <= remain(). Default just reads data
 	// and discards it. Value of remain() is updated AFTER this call succeeds, not
 	// before. set_remain() should NOT be called from this.
-	virtual blargg_err_t skip_v( int n );
+	virtual blargg_err_t skip_v( BOOST::uint64_t n );
 
 // Implementation
 public:
@@ -126,7 +126,7 @@ public:
 	virtual ~Std_File_Reader();
 	
 protected:
-	virtual blargg_err_t read_v( void*, int );
+	virtual blargg_err_t read_v( void*, long );
 	virtual blargg_err_t seek_v( BOOST::uint64_t );
 
 private:
@@ -142,8 +142,8 @@ public:
 
 // Implementation
 protected:
-	virtual blargg_err_t read_v( void*, int );
+	virtual blargg_err_t read_v( void*, long );
-	virtual blargg_err_t seek_v( int );
+	virtual blargg_err_t seek_v( BOOST::uint64_t );
 
 private:
 	const char* const begin;
@@ -158,7 +158,7 @@ public:
 
 // Implementation
 protected:
-	virtual blargg_err_t read_v( void*, int );
+	virtual blargg_err_t read_v( void*, long );
 
 private:
 	Data_Reader* const in;
@@ -175,12 +175,12 @@ public:
 
 // Implementation
 protected:
-	virtual blargg_err_t read_v( void*, int );
+	virtual blargg_err_t read_v( void*, long );
 
 private:
 	Data_Reader* const in;
 	void const* header;
-	int header_remain;
+	long header_remain;
 };
 
 
@@ -189,7 +189,7 @@ extern "C" { // necessary to be usable from C
 	typedef const char* (*callback_reader_func_t)(
 		void* user_data,    // Same value passed to constructor
 		void* out,          // Buffer to place data into
-		int count           // Number of bytes to read
+		long count           // Number of bytes to read
 	);
 }
 class Callback_Reader : public Data_Reader {
@@ -199,7 +199,7 @@ public:
 	
 // Implementation
 protected:
-	virtual blargg_err_t read_v( void*, int );
+	virtual blargg_err_t read_v( void*, long );
 
 private:
 	callback_t const callback;
@@ -212,7 +212,7 @@ extern "C" { // necessary to be usable from C
 	typedef const char* (*callback_file_reader_func_t)(
 		void* user_data,    // Same value passed to constructor
 		void* out,          // Buffer to place data into
-		int count,          // Number of bytes to read
+		long count,          // Number of bytes to read
 		BOOST::uint64_t pos             // Position in file to read from
 	);
 }
@@ -223,8 +223,8 @@ public:
 	
 // Implementation
 protected:
-	virtual blargg_err_t read_v( void*, int );
+	virtual blargg_err_t read_v( void*, long );
-	virtual blargg_err_t seek_v( int );
+	virtual blargg_err_t seek_v( BOOST::uint64_t );
 
 private:
 	callback_t const callback;
@@ -250,8 +250,8 @@ public:
 	~Gzip_File_Reader();
 	
 protected:
-	virtual blargg_err_t read_v( void*, int );
+	virtual blargg_err_t read_v( void*, long );
-	virtual blargg_err_t seek_v( int );
+	virtual blargg_err_t seek_v( BOOST::uint64_t );
 	
 private:
 	// void* so "zlib.h" doesn't have to be included here

Frameworks/File_Extractor/File_Extractor/fex/File_Extractor.cpp

@@ -323,7 +323,7 @@ blargg_err_t File_Extractor::data_v( void const** out )
 	return err;
 }
 
-blargg_err_t File_Extractor::extract_v( void* out, int count )
+blargg_err_t File_Extractor::extract_v( void* out, long count )
 {
 	void const* p;
 	RETURN_ERR( data( &p ) );
@@ -332,7 +332,7 @@ blargg_err_t File_Extractor::extract_v( void* out, int count )
 	return blargg_ok;
 }
 
-blargg_err_t File_Extractor::read_v( void* out, int count )
+blargg_err_t File_Extractor::read_v( void* out, long count )
 {
 	if ( data_ptr_ )
 		return File_Extractor::extract_v( out, count );

Frameworks/File_Extractor/File_Extractor/fex/File_Extractor.h

@@ -118,7 +118,7 @@ protected:
 	virtual blargg_err_t data_v( const void** out );
 	
 	// Extract next n bytes
-	virtual blargg_err_t extract_v( void* out, int n );
+	virtual blargg_err_t extract_v( void* out, long n );
 	
 // Implementation
 public:
@@ -158,7 +158,7 @@ private:
 	
 	// Data_Reader overrides
 	// TODO: override skip_v?
-	virtual blargg_err_t read_v( void* out, int n );
+	virtual blargg_err_t read_v( void* out, long n );
 };
 
 struct fex_type_t_

Frameworks/File_Extractor/File_Extractor/fex/Gzip_Extractor.cpp

@@ -92,7 +92,7 @@ blargg_err_t Gzip_Extractor::rewind_v()
 	return blargg_ok;
 }
 
-blargg_err_t Gzip_Extractor::extract_v( void* p, int n )
+blargg_err_t Gzip_Extractor::extract_v( void* p, long n )
 {
 	return gr.read( p, n );
 }

Frameworks/File_Extractor/File_Extractor/fex/Gzip_Extractor.h

@@ -22,7 +22,7 @@ protected:
 	virtual blargg_err_t rewind_v();
 
 	virtual blargg_err_t stat_v();
-	virtual blargg_err_t extract_v( void*, int );
+	virtual blargg_err_t extract_v( void*, long );
 	
 private:
 	Gzip_Reader gr;

Frameworks/File_Extractor/File_Extractor/fex/Gzip_Reader.cpp

@@ -25,7 +25,7 @@ Gzip_Reader::Gzip_Reader()
 Gzip_Reader::~Gzip_Reader()
 { }
 
-static blargg_err_t gzip_reader_read( void* file, void* out, int* count )
+static blargg_err_t gzip_reader_read( void* file, void* out, long* count )
 {
 	return STATIC_CAST(File_Reader*,file)->read_avail( out, count );
 }
@@ -37,7 +37,7 @@ blargg_err_t Gzip_Reader::calc_size()
 	if ( inflater.deflated() )
 	{
 		byte trailer [8];
-		int old_pos = in->tell();
+        BOOST::uint64_t old_pos = in->tell();
 		RETURN_ERR( in->seek( size_ - sizeof trailer ) );
 		RETURN_ERR( in->read( trailer, sizeof trailer ) );
 		RETURN_ERR( in->seek( old_pos ) );
@@ -72,10 +72,10 @@ void Gzip_Reader::close()
 	inflater.end();
 }
 
-blargg_err_t Gzip_Reader::read_v( void* out, int count )
+blargg_err_t Gzip_Reader::read_v( void* out, long count )
 {
 	assert( in );
-	int actual = count;
+	long actual = count;
 	RETURN_ERR( inflater.read( out, &actual ) );
 	
 	if ( actual != count )

Frameworks/File_Extractor/File_Extractor/fex/Gzip_Reader.h

@@ -32,12 +32,12 @@ public:
 	virtual ~Gzip_Reader();
 	
 protected:
-	virtual blargg_err_t read_v( void*, int );
+	virtual blargg_err_t read_v( void*, long );
 
 private:
 	File_Reader* in;
 	unsigned crc32_;
-	int size_;
+    BOOST::uint64_t size_;
 	Zlib_Inflater inflater;
 
 	blargg_err_t calc_size();

Frameworks/File_Extractor/File_Extractor/fex/Rar_Extractor.cpp

@@ -81,10 +81,8 @@ static inline unrar_err_t handle_err( Rar_Extractor::read_callback_t* h, blargg_
 
 extern "C"
 {
-	static unrar_err_t my_unrar_read( void* data, void* out, int* count, unrar_pos_t pos )
+	static unrar_err_t my_unrar_read( void* data, void* out, long* count, unrar_pos_t pos )
 	{
-		// TODO: 64-bit file support
-		
 		Rar_Extractor::read_callback_t* h = STATIC_CAST(Rar_Extractor::read_callback_t*,data);
 		if ( h->pos != pos )
 		{
@@ -145,7 +143,7 @@ blargg_err_t Rar_Extractor::skip_unextractables()
 		unrar_info_t const* info = unrar_info( unrar );
 		
 		set_name( info->name, (info->name_w && *info->name_w) ? info->name_w : NULL );
-		set_info( info->size, info->dos_date, (info->is_crc32 ? info->crc : 0) );
+		set_info( info->size, (unsigned int)info->dos_date, (unsigned int)(info->is_crc32 ? info->crc : 0) );
 	}
 	
 	return blargg_ok;
@@ -184,7 +182,7 @@ blargg_err_t Rar_Extractor::data_v( void const** out )
 	return convert_err( unrar_extract_mem( unrar, out ) );
 }
 
-blargg_err_t Rar_Extractor::extract_v( void* out, int count )
+blargg_err_t Rar_Extractor::extract_v( void* out, long count )
 {
 	// We can read entire file directly into user buffer
 	if ( count == size() )

Frameworks/File_Extractor/File_Extractor/fex/Rar_Extractor.h

@@ -29,7 +29,7 @@ protected:
 	virtual blargg_err_t seek_arc_v( fex_pos_t );
 
 	virtual blargg_err_t data_v( void const** );
-	virtual blargg_err_t extract_v( void*, int );
+	virtual blargg_err_t extract_v( void*, long );
 	
 private:
 	unrar_t* unrar;

Frameworks/File_Extractor/File_Extractor/fex/Zip7_Extractor.cpp

@@ -231,7 +231,7 @@ blargg_err_t Zip7_Extractor::next_v()
                 localtime_r( &_time, &tm );
 #endif
 
-				date = ( tm.tm_sec >> 1 ) & 0x1F |
+				date = (( tm.tm_sec >> 1 ) & 0x1F) |
 					(( tm.tm_min & 0x3F ) << 5 ) |
 					(( tm.tm_hour & 0x1F ) << 11 ) |
 					(( tm.tm_mday & 0x1F ) << 16 ) |
@@ -243,11 +243,12 @@ blargg_err_t Zip7_Extractor::next_v()
 			name16.resize( name_length );
 			SzArEx_GetFileNameUtf16( &impl->db, index, ( UInt16 * ) name16.begin() );
 			char * temp = blargg_to_utf8( name16.begin() );
-			if ( !temp ) temp = "";
+            const char * name_8 = temp;
-			size_t utf8_length = strlen( temp );
+			if ( !temp ) name_8 = "";
+			size_t utf8_length = strlen( name_8 );
 			name8.resize( utf8_length + 1 );
-			memcpy( name8.begin(), temp, utf8_length + 1 );
+			memcpy( name8.begin(), name_8, utf8_length + 1 );
-			free( temp );
+			if ( temp ) free( temp );
 			set_name( name8.begin(), name16.begin() );
 			set_info( item.Size, 0, (item.CrcDefined ? item.Crc : 0) );
 			break;

Frameworks/File_Extractor/File_Extractor/fex/Zip7_Extractor.h

@@ -26,7 +26,7 @@ protected:
 	
 private:
 	Zip7_Extractor_Impl* impl;
-	int index;
+	fex_pos_t index;
 	blargg_vector<char> name8;
     blargg_vector<blargg_wchar_t> name16;
 	

Frameworks/File_Extractor/File_Extractor/fex/Zip_Extractor.cpp

@@ -130,7 +130,7 @@ blargg_err_t Zip_Extractor::open_path_v()
 }
 
 inline
-void Zip_Extractor::reorder_entry_header( int offset )
+void Zip_Extractor::reorder_entry_header( long offset )
 {
 	catalog [offset + 0] = 0;
 	catalog [offset + 4] = 'P';
@@ -149,7 +149,7 @@ blargg_err_t Zip_Extractor::open_v()
 	RETURN_ERR( arc().read( catalog.begin(), catalog.size() ) );
 
 	// Find end-of-catalog entry
-	BOOST::uint64_t end_pos = catalog.size() - end_entry_size;
+	BOOST::int64_t end_pos = catalog.size() - end_entry_size;
 	while ( end_pos >= 0 && memcmp( &catalog [end_pos], "PK\5\6", 4 ) )
 		end_pos--;
 	if ( end_pos < 0 )
@@ -162,13 +162,13 @@ blargg_err_t Zip_Extractor::open_v()
 
 	// Find file offset of beginning of catalog
 	catalog_begin = get_le32( end_entry.dir_offset );
-	int catalog_size = end_pos - catalog_begin;
+    BOOST::int64_t catalog_size = end_pos - catalog_begin;
 	if ( catalog_size < 0 )
 		return blargg_err_file_corrupt;
 	catalog_size += end_entry_size;
 
 	// See if catalog is entirely contained in bytes already read
-	BOOST::uint64_t begin_offset = catalog_begin - file_pos;
+	BOOST::int64_t begin_offset = catalog_begin - file_pos;
 	if ( begin_offset >= 0 )
 		memmove( catalog.begin(), &catalog [begin_offset], catalog_size );
 
@@ -237,7 +237,7 @@ blargg_err_t Zip_Extractor::update_info( bool advance_first )
 		}
 
 		unsigned len = get_le16( e.filename_len );
-		int next_offset = catalog_pos + entry_size + len + get_le16( e.extra_len ) +
+        BOOST::int64_t next_offset = catalog_pos + entry_size + len + get_le16( e.extra_len ) +
 				get_le16( e.comment_len );
 		if ( (unsigned) next_offset > catalog.size() - end_entry_size )
 			return blargg_err_file_corrupt;
@@ -294,7 +294,7 @@ void Zip_Extractor::clear_file_v()
 	buf.end();
 }
 
-blargg_err_t Zip_Extractor::inflater_read( void* data, void* out, int* count )
+blargg_err_t Zip_Extractor::inflater_read( void* data, void* out, long* count )
 {
 	Zip_Extractor& self = *STATIC_CAST(Zip_Extractor*,data);
 	
@@ -306,14 +306,14 @@ blargg_err_t Zip_Extractor::inflater_read( void* data, void* out, int* count )
 	return self.arc().read( out, *count );
 }
 
-blargg_err_t Zip_Extractor::fill_buf( int offset, int buf_size, int initial_read )
+blargg_err_t Zip_Extractor::fill_buf( long offset, long buf_size, long initial_read )
 {
 	raw_remain = arc().size() - offset;
 	RETURN_ERR( arc().seek( offset ) );
 	return buf.begin( inflater_read, this, buf_size, initial_read );
 }
 
-blargg_err_t Zip_Extractor::first_read( int count )
+blargg_err_t Zip_Extractor::first_read( long count )
 {
 	entry_t const& e = (entry_t&) catalog [catalog_pos];
 	
@@ -372,17 +372,25 @@ blargg_err_t Zip_Extractor::first_read( int count )
 	return buf.set_mode( (file_deflated ? buf.mode_raw_deflate : buf.mode_copy), buf_offset );
 }
 
-blargg_err_t Zip_Extractor::extract_v( void* out, int count )
+blargg_err_t Zip_Extractor::extract_v( void* out, long count )
 {
 	if ( tell() == 0 )
 		RETURN_ERR( first_read( count ) );
 	
-	int actual = count;
+	long actual = count;
 	RETURN_ERR( buf.read( out, &actual ) );
 	if ( actual < count )
 		return blargg_err_file_corrupt;
-	
+
-	crc = ::crc32( crc, (byte const*) out, count );
+    long count_crc = count;
+    const byte * out_crc = (const byte *) out;
+    while ( count_crc > 0 )
+    {
+        unsigned int count_i = (unsigned int)( count_crc > UINT_MAX ? UINT_MAX : count_crc );
+        crc = ::crc32( crc, out_crc, count_i );
+        out_crc += count_i;
+        count_crc -= count_i;
+    }
 	if ( count == reader().remain() && crc != correct_crc )
 		return blargg_err_file_corrupt;
 	

Frameworks/File_Extractor/File_Extractor/fex/Zip_Extractor.h

@@ -23,23 +23,23 @@ protected:
 	virtual fex_pos_t    tell_arc_v() const;
 	virtual blargg_err_t seek_arc_v( fex_pos_t );
 	
-	virtual blargg_err_t extract_v( void*, int );
+	virtual blargg_err_t extract_v( void*, long );
 
 private:
 	blargg_vector<char> catalog;
-	int catalog_begin;  // offset of first catalog entry in file (to detect corruption)
+    BOOST::int64_t catalog_begin;  // offset of first catalog entry in file (to detect corruption)
-	int catalog_pos;    // position of current entry in catalog
+    BOOST::int64_t catalog_pos;    // position of current entry in catalog
 	BOOST::uint64_t raw_remain;     // bytes remaining to be read from zip file for current file
-	unsigned crc;       // ongoing CRC of extracted bytes
+	unsigned long crc;       // ongoing CRC of extracted bytes
-	unsigned correct_crc;
+	unsigned long correct_crc;
 	bool file_deflated;
 	Zlib_Inflater buf;
 
-	blargg_err_t fill_buf( int offset, int buf_size, int initial_read );
+	blargg_err_t fill_buf( long offset, long buf_size, long initial_read );
 	blargg_err_t update_info( bool advance_first );
-	blargg_err_t first_read( int count );
+	blargg_err_t first_read( long count );
-	void reorder_entry_header( int offset );
+	void reorder_entry_header( long offset );
-	static blargg_err_t inflater_read( void* data, void* out, int* count );
+	static blargg_err_t inflater_read( void* data, void* out, long* count );
 };
 
 #endif

Frameworks/File_Extractor/File_Extractor/fex/Zlib_Inflater.cpp

@@ -59,17 +59,17 @@ Zlib_Inflater::~Zlib_Inflater()
 	end();
 }
 
-blargg_err_t Zlib_Inflater::fill_buf( int count )
+blargg_err_t Zlib_Inflater::fill_buf( long count )
 {
 	byte* out = buf.end() - count;
 	RETURN_ERR( callback( user_data, out, &count ) );
-	zbuf.avail_in = count;
+	zbuf.avail_in = (uInt) count;
 	zbuf.next_in  = out;
 	return blargg_ok;
 }
 
 blargg_err_t Zlib_Inflater::begin( callback_t new_callback, void* new_user_data,
-		int new_buf_size, int initial_read )
+		long new_buf_size, long initial_read )
 {
 	callback  = new_callback;
 	user_data = new_user_data;
@@ -163,15 +163,15 @@ blargg_err_t Zlib_Inflater::read_all( void* out, int count )
 }
 */
 
-blargg_err_t Zlib_Inflater::read( void* out, int* count_io )
+blargg_err_t Zlib_Inflater::read( void* out, long* count_io )
 {
-	int remain = *count_io;
+	long remain = *count_io;
 	if ( remain && zbuf.next_in )
 	{
 		if ( deflated_ )
 		{
 			zbuf.next_out  = (Bytef*) out;
-			zbuf.avail_out = remain;
+			zbuf.avail_out = (uInt)( remain > UINT_MAX ? UINT_MAX : remain );
 			
 			while ( 1 )
 			{
@@ -232,7 +232,7 @@ blargg_err_t Zlib_Inflater::read( void* out, int* count_io )
 				// read large request directly
 				if ( remain + zbuf.total_out % block_size >= buf.size() )
 				{
-					int count = remain;
+					long count = remain;
 					RETURN_ERR( callback( user_data, out, &count ) );
 					zbuf.total_out += count;
 					out = (char*) out + count;

Frameworks/File_Extractor/File_Extractor/fex/Zlib_Inflater.h

@@ -13,13 +13,13 @@ public:
 
 	// Reads at most min(*count,bytes_until_eof()) bytes into *out and set *count
 	// to that number, or returns error if that many can't be read.
-	typedef blargg_err_t (*callback_t)( void* user_data, void* out, int* count );
+	typedef blargg_err_t (*callback_t)( void* user_data, void* out, long* count );
 
 	// Begins by setting callback and filling buffer. Default buffer is 16K and
 	// filled to 4K, or specify buf_size and initial_read for custom buffer size
 	// and how much to read initially.
 	blargg_err_t begin( callback_t, void* user_data,
-			int buf_size = 0, int initial_read = 0 );
+			long buf_size = 0, long initial_read = 0 );
 
 	// Data read into buffer by begin()
 	const unsigned char* data() const   { return zbuf.next_in; }
@@ -39,10 +39,10 @@ public:
 	// number of bytes read (less than requested if end of data was reached).
 	// Buffers source data internally, even in copy mode, so input file can be
 	// unbuffered without sacrificing performance.
-	blargg_err_t read( void* out, int* count_io );
+	blargg_err_t read( void* out, long* count_io );
 
 	// Total number of bytes read since begin()
-	int tell() const                    { return zbuf.total_out; }
+	long tell() const                    { return zbuf.total_out; }
 
 	// Ends inflation and frees memory
 	void end();
@@ -64,7 +64,7 @@ private:
 	callback_t callback;
 	void* user_data;
 
-	blargg_err_t fill_buf( int count );
+	blargg_err_t fill_buf( long count );
 };
 
 #endif

Frameworks/File_Extractor/File_Extractor/unrar/archive.cpp

@@ -20,7 +20,7 @@ Archive::Archive() : Raw( this )
 bool Archive::IsSignature(byte *D)
 {
 	bool Valid=false;
-	if (D[0]==0x52)
+	if (D[0]==0x52) {
 #ifndef SFX_MODULE
 		if (D[1]==0x45 && D[2]==0x7e && D[3]==0x5e)
 		{
@@ -34,6 +34,7 @@ bool Archive::IsSignature(byte *D)
 				OldFormat=false;
 				Valid=true;
 			}
+    }
 	return(Valid);
 }
 

Frameworks/File_Extractor/File_Extractor/unrar/archive.hpp

@@ -9,7 +9,7 @@ class Archive:public File
 private:
 	bool IsSignature(byte *D);
 	void ConvertUnknownHeader();
-	int ReadOldHeader();
+	long ReadOldHeader();
 
 	RawRead Raw;
 

Frameworks/File_Extractor/File_Extractor/unrar/arcread.cpp

@@ -121,7 +121,7 @@ unrar_err_t Archive::ReadHeader()
 					if (hd->Flags & LHD_UNICODE)
 					{
 						EncodeFileName NameCoder;
-						int Length=strlen(FileName);
+						int Length=(int)strlen(FileName);
 						if (Length==hd->NameSize)
 						{
 							UtfToWide(FileName,hd->FileNameW,sizeof(hd->FileNameW)/sizeof(hd->FileNameW[0])-1);
@@ -216,7 +216,7 @@ unrar_err_t Archive::ReadHeader()
 
 // Rar.Read()s are checked by caller of ReadOldHeader() (see above)
 #ifndef SFX_MODULE
-int Archive::ReadOldHeader()
+long Archive::ReadOldHeader()
 {
 	Raw.Reset();
 	if (CurBlockPos<=SFXSize)

Frameworks/File_Extractor/File_Extractor/unrar/array.hpp

@@ -5,18 +5,18 @@ template <class T> class Array
 {
 private:
 	T *Buffer;
-	int BufSize;
+	long BufSize;
-	int AllocSize;
+	long AllocSize;
 public:
 	Rar_Error_Handler& ErrHandler;
 	Array(Rar_Error_Handler*);
-	Array(int Size,Rar_Error_Handler*);
+	Array(long Size,Rar_Error_Handler*);
 	~Array();
 	inline void CleanData();
-    inline T& operator [](int Item);
+    inline T& operator [](long Item);
-    inline int Size();
+    inline long Size();
-	void Add(int Items);
+	void Add(long Items);
-	void Alloc(int Items);
+	void Alloc(long Items);
 	void Reset();
     void operator = (Array<T> &Src);
 	void Push(T Item);
@@ -37,7 +37,7 @@ template <class T> Array<T>::Array(Rar_Error_Handler* eh) : ErrHandler( *eh )
 }
 
 
-template <class T> Array<T>::Array(int Size, Rar_Error_Handler* eh) : ErrHandler( *eh )
+template <class T> Array<T>::Array(long Size, Rar_Error_Handler* eh) : ErrHandler( *eh )
 {
 	Buffer=(T *)rarmalloc(sizeof(T)*Size);
 	if (Buffer==NULL && Size!=0)
@@ -54,28 +54,28 @@ template <class T> Array<T>::~Array()
 }
 
 
-template <class T> inline T& Array<T>::operator [](int Item)
+template <class T> inline T& Array<T>::operator [](long Item)
 {
   return(Buffer[Item]);
 }
 
 
-template <class T> inline int Array<T>::Size()
+template <class T> inline long Array<T>::Size()
 {
   return(BufSize);
 }
 
 
-template <class T> void Array<T>::Add(int Items)
+template <class T> void Array<T>::Add(long Items)
 {
-	int BufSize = this->BufSize; // don't change actual vars until alloc succeeds
+	long BufSize = this->BufSize; // don't change actual vars until alloc succeeds
-	T*  Buffer  = this->Buffer;
+	T*  Buffer   = this->Buffer;
 	
 	BufSize+=Items;
 	if (BufSize>AllocSize)
 	{
-		int Suggested=AllocSize+AllocSize/4+32;
+		long Suggested=AllocSize+AllocSize/4+32;
-		int NewSize=Max(BufSize,Suggested);
+		long NewSize=Max(BufSize,Suggested);
 
 		Buffer=(T *)rarrealloc(Buffer,NewSize*sizeof(T));
 		if (Buffer==NULL)
@@ -88,7 +88,7 @@ template <class T> void Array<T>::Add(int Items)
 }
 
 
-template <class T> void Array<T>::Alloc(int Items)
+template <class T> void Array<T>::Alloc(long Items)
 {
 	if (Items>AllocSize)
 		Add(Items-BufSize);

Frameworks/File_Extractor/File_Extractor/unrar/coder.cpp

@@ -29,7 +29,7 @@ void RangeCoder::InitDecoder(Unpack *UnpackRead)
 }
 
 
-inline int RangeCoder::GetCurrentCount()
+inline long RangeCoder::GetCurrentCount()
 {
 	return (code-low)/(range /= SubRange.scale);
 }

Frameworks/File_Extractor/File_Extractor/unrar/coder.hpp

@@ -8,7 +8,7 @@ class RangeCoder
 {
 public:
 	void InitDecoder(Unpack *UnpackRead);
-	inline int GetCurrentCount();
+	inline long GetCurrentCount();
 	inline uint GetCurrentShiftCount(uint SHIFT);
 	inline void Decode();
 	inline void PutChar(unsigned int c);

Frameworks/File_Extractor/File_Extractor/unrar/extract.cpp

@@ -75,8 +75,8 @@ unrar_err_t CmdExtract::ExtractCurrentFile( bool SkipSolid, bool check_compatibi
 	
 	if (!SkipSolid)
 	{
-	    if (Arc.OldFormat && UINT32(DataIO.UnpFileCRC)==UINT32(Arc.NewLhd.FileCRC) ||
+	    if ((Arc.OldFormat && UINT32(DataIO.UnpFileCRC)==UINT32(Arc.NewLhd.FileCRC)) ||
-	        !Arc.OldFormat && UINT32(DataIO.UnpFileCRC)==UINT32(Arc.NewLhd.FileCRC^0xffffffff))
+	        (!Arc.OldFormat && UINT32(DataIO.UnpFileCRC)==UINT32(Arc.NewLhd.FileCRC^0xffffffff)))
 	    {
 	    	// CRC is correct
 	    }
@@ -98,7 +98,7 @@ void CmdExtract::UnstoreFile(Int64 DestUnpSize)
 	Buffer.Alloc(Min(DestUnpSize,0x10000));
 	while (1)
 	{
-		unsigned int Code=DataIO.UnpRead(&Buffer[0],Buffer.Size());
+		uint Code=DataIO.UnpRead(&Buffer[0],Buffer.Size());
 		if (Code==0 || (int)Code==-1)
 			break;
 		Code=Code<DestUnpSize ? Code:int64to32(DestUnpSize);

Frameworks/File_Extractor/File_Extractor/unrar/getbits.cpp

@@ -22,7 +22,7 @@ void BitInput::handle_mem_error( Rar_Error_Handler& ErrHandler )
 		ErrHandler.MemoryError();
 }
 
-void BitInput::faddbits(int Bits)
+void BitInput::faddbits(long Bits)
 {
 	addbits(Bits);
 }

Frameworks/File_Extractor/File_Extractor/unrar/getbits.hpp

@@ -19,7 +19,7 @@ public:
 	{
 		InAddr=InBit=0;
 	}
-	void addbits(int Bits)
+	void addbits(long Bits)
 	{
 		Bits+=InBit;
 		InAddr+=Bits>>3;
@@ -27,13 +27,13 @@ public:
 	}
 	unsigned int getbits()
 	{
-		unsigned int BitField=(uint)InBuf[InAddr] << 16;
+		uint BitField=(uint)InBuf[InAddr] << 16;
 		BitField|=(uint)InBuf[InAddr+1] << 8;
 		BitField|=(uint)InBuf[InAddr+2];
 		BitField >>= (8-InBit);
 		return(BitField & 0xffff);
 	}
-	void faddbits(int Bits);
+	void faddbits(long Bits);
 	unsigned int fgetbits();
 	bool Overflow(int IncPtr) {return(InAddr+IncPtr>=MAX_SIZE);}
 };

Frameworks/File_Extractor/File_Extractor/unrar/model.cpp

@@ -399,7 +399,7 @@ inline bool PPM_CONTEXT::decodeSymbol1(ModelPPM *Model)
 	Model->Coder.SubRange.scale=U.SummFreq;
 	STATE* p=U.Stats;
 	int i, HiCnt;
-	int count=Model->Coder.GetCurrentCount();
+	long count=Model->Coder.GetCurrentCount();
 	if (count>=Model->Coder.SubRange.scale)
 		return(false);
 	if (count < (HiCnt=p->Freq))
@@ -450,7 +450,7 @@ inline void PPM_CONTEXT::update2(ModelPPM *Model,STATE* p)
 }
 
 
-inline SEE2_CONTEXT* PPM_CONTEXT::makeEscFreq2(ModelPPM *Model,int Diff)
+inline SEE2_CONTEXT* PPM_CONTEXT::makeEscFreq2(ModelPPM *Model,long Diff)
 {
 	SEE2_CONTEXT* psee2c;
 	if (NumStats != 256)
@@ -474,7 +474,7 @@ inline SEE2_CONTEXT* PPM_CONTEXT::makeEscFreq2(ModelPPM *Model,int Diff)
 
 inline bool PPM_CONTEXT::decodeSymbol2(ModelPPM *Model)
 {
-	int count, HiCnt, i=NumStats-Model->NumMasked;
+	long count, HiCnt, i=NumStats-Model->NumMasked;
 	SEE2_CONTEXT* psee2c=makeEscFreq2(Model,i);
 	STATE* ps[256], ** pps=ps, * p=U.Stats-1;
 	HiCnt=0;

Frameworks/File_Extractor/File_Extractor/unrar/model.hpp

@@ -75,7 +75,7 @@ struct PPM_CONTEXT
 		inline void update2(ModelPPM *Model,STATE* p); //   BCDE   successor
 		void rescale(ModelPPM *Model);
 		inline PPM_CONTEXT* createChild(ModelPPM *Model,STATE* pStats,STATE& FirstState);
-		inline SEE2_CONTEXT* makeEscFreq2(ModelPPM *Model,int Diff);
+		inline SEE2_CONTEXT* makeEscFreq2(ModelPPM *Model,long Diff);
 };
 
 #ifndef STRICT_ALIGNMENT_REQUIRED

Frameworks/File_Extractor/File_Extractor/unrar/rar.hpp

@@ -96,10 +96,6 @@ struct Rar_Allocator
 	#define PRESENT_INT32
 #endif
 
-typedef unsigned char    byte;   //8 bits
-typedef unsigned short   ushort; //preferably 16 bits, but can be more
-typedef unsigned int     uint;   //32 bits or more
-
 typedef blargg_wchar_t wchar;
 
 #define SHORT16(x) (sizeof(ushort)==2 ? (ushort)(x):((x)&0xffff))
@@ -127,7 +123,7 @@ ushort OldCRC(ushort StartCRC,const void *Addr,size_t Size);
 //// rartime.hpp
 struct RarTime
 {
-	unsigned time;
+	uint time;
     void SetDos(uint DosTime) { time = DosTime; }
 };
 
@@ -149,8 +145,8 @@ private:
     bool SkipUnpCRC;
 
 public:
-	int UnpRead(byte *Addr,uint Count);
+	long UnpRead(byte *Addr,long Count);
-    void UnpWrite(byte *Addr,uint Count);
+    void UnpWrite(byte *Addr,long Count);
 	void SetSkipUnpCRC( bool b ) { SkipUnpCRC = b; }
 	void SetPackedSizeToRead( Int64 n ) { UnpPackedSize = n; }
 
@@ -158,7 +154,7 @@ public:
 
 	void Seek(Int64 Offset, int Method = 0 ) { (void)Method; Tell_ = Offset; }
 	Int64 Tell() { return Tell_; }
-	int Read( void* p, int n );
+	long Read( void* p, long n );
 };
 
 //// rar.hpp

Frameworks/File_Extractor/File_Extractor/unrar/rarvm.cpp

@@ -139,10 +139,10 @@ inline uint* RarVM::GetOperand(VM_PreparedOperand *CmdOp)
 void RarVM::Execute(VM_PreparedProgram *Prg)
 {
 	memcpy(R,Prg->InitR,sizeof(Prg->InitR));
-	unsigned int GlobalSize=Min(Prg->GlobalData.Size(),VM_GLOBALMEMSIZE);
+	uint GlobalSize=Min(Prg->GlobalData.Size(),VM_GLOBALMEMSIZE);
 	if (GlobalSize)
 		memcpy(Mem+VM_GLOBALMEMADDR,&Prg->GlobalData[0],GlobalSize);
-	unsigned int StaticSize=Min(Prg->StaticData.Size(),VM_GLOBALMEMSIZE-GlobalSize);
+	uint StaticSize=Min(Prg->StaticData.Size(),VM_GLOBALMEMSIZE-GlobalSize);
 	if (StaticSize)
 		memcpy(Mem+VM_GLOBALMEMADDR+GlobalSize,&Prg->StaticData[0],StaticSize);
 
@@ -185,7 +185,7 @@ Note:
     return(false);                      \
 	Cmd=PreparedCode+(IP);
 
-bool RarVM::ExecuteCode(VM_PreparedCommand *PreparedCode,int CodeSize)
+bool RarVM::ExecuteCode(VM_PreparedCommand *PreparedCode,long CodeSize)
 {
 	int MaxOpCount=25000000;
 	VM_PreparedCommand *Cmd=PreparedCode;
@@ -449,8 +449,8 @@ bool RarVM::ExecuteCode(VM_PreparedCommand *PreparedCode,int CodeSize)
 #endif
 			case VM_PUSHA:
 				{
-					const int RegCount=sizeof(R)/sizeof(R[0]);
+					const uint RegCount=sizeof(R)/sizeof(R[0]);
-					for (int I=0,SP=R[7]-4;I<RegCount;I++,SP-=4)
+					for (uint I=0,SP=R[7]-4;I<RegCount;I++,SP-=4)
 						SET_VALUE(false,(uint *)&Mem[SP & VM_MEMMASK],R[I]);
 					R[7]-=RegCount*4;
 				}
@@ -506,7 +506,7 @@ bool RarVM::ExecuteCode(VM_PreparedCommand *PreparedCode,int CodeSize)
 					uint Result=UINT32(Value1+GET_VALUE(Cmd->ByteMode,Op2)+FC);
 					if (Cmd->ByteMode)
 						Result&=0xff;
-					Flags=(Result<Value1 || Result==Value1 && FC)|(Result==0 ? VM_FZ:(Result&VM_FS));
+					Flags=(Result<Value1 || (Result==Value1 && FC))|(Result==0 ? VM_FZ:(Result&VM_FS));
 					SET_VALUE(Cmd->ByteMode,Op1,Result);
 				}
 				break;
@@ -517,7 +517,7 @@ bool RarVM::ExecuteCode(VM_PreparedCommand *PreparedCode,int CodeSize)
 					uint Result=UINT32(Value1-GET_VALUE(Cmd->ByteMode,Op2)-FC);
 					if (Cmd->ByteMode)
 						Result&=0xff;
-					Flags=(Result>Value1 || Result==Value1 && FC)|(Result==0 ? VM_FZ:(Result&VM_FS));
+					Flags=(Result>Value1 || (Result==Value1 && FC))|(Result==0 ? VM_FZ:(Result&VM_FS));
 					SET_VALUE(Cmd->ByteMode,Op1,Result);
 				}
 				break;
@@ -544,7 +544,7 @@ bool RarVM::ExecuteCode(VM_PreparedCommand *PreparedCode,int CodeSize)
 
 
 
-void RarVM::Prepare(byte *Code,int CodeSize,VM_PreparedProgram *Prg)
+void RarVM::Prepare(byte *Code,long CodeSize,VM_PreparedProgram *Prg)
 {
 	InitBitInput();
 	memcpy(InBuf,Code,Min(CodeSize,BitInput::MAX_SIZE));
@@ -583,7 +583,7 @@ void RarVM::Prepare(byte *Code,int CodeSize,VM_PreparedProgram *Prg)
 
 		if (DataFlag&0x8000)
 		{
-			int DataSize=ReadData(*this)+1;
+			uint DataSize=ReadData(*this)+1;
 			for (int I=0;InAddr<CodeSize && I<DataSize;I++)
 			{
 				Prg->StaticData.Add(1);
@@ -627,7 +627,7 @@ void RarVM::Prepare(byte *Code,int CodeSize,VM_PreparedProgram *Prg)
 					if (CurCmd->Op1.Type==VM_OPINT && (VM_CmdFlags[CurCmd->OpCode]&(VMCF_JUMP|VMCF_PROC)))
 					{
 						// Calculating jump distance.
-						int Distance=CurCmd->Op1.Data;
+						long Distance=CurCmd->Op1.Data;
 						if (Distance>=256)
 							Distance-=256;
 						else
@@ -773,7 +773,7 @@ uint RarVM::ReadData(BitInput &Inp)
 }
 
 
-void RarVM::SetMemory(unsigned int Pos,byte *Data,unsigned int DataSize)
+void RarVM::SetMemory(uint Pos,byte *Data,uint DataSize)
 {
 	if (Pos<VM_MEMSIZE && Data!=Mem+Pos)
 		memmove(Mem+Pos,Data,Min(DataSize,VM_MEMSIZE-Pos));
@@ -800,6 +800,8 @@ void RarVM::Optimize(VM_PreparedProgram *Prg)
 			case VM_CMP:
 				Cmd->OpCode=Cmd->ByteMode ? VM_CMPB:VM_CMPD;
 				continue;
+                
+            default: break;
 		}
 		if ((VM_CmdFlags[Cmd->OpCode] & VMCF_CHFLAGS)==0)
 			continue;
@@ -843,6 +845,8 @@ void RarVM::Optimize(VM_PreparedProgram *Prg)
 			case VM_NEG:
 				Cmd->OpCode=Cmd->ByteMode ? VM_NEGB:VM_NEGD;
 				continue;
+                
+            default: break;
 		}
 	}
 }
@@ -850,7 +854,7 @@ void RarVM::Optimize(VM_PreparedProgram *Prg)
 
 
 #ifdef VM_STANDARDFILTERS
-VM_StandardFilters RarVM::IsStandardFilter(byte *Code,int CodeSize)
+VM_StandardFilters RarVM::IsStandardFilter(byte *Code,long CodeSize)
 {
 	static const
 	struct StandardFilterSignature
@@ -891,7 +895,7 @@ void RarVM::ExecuteStandardFilter(VM_StandardFilters FilterType)
 		case VMSF_E8E9:
 			{
 				byte *Data=Mem;
-				int DataSize=R[4];
+				long DataSize=R[4];
 				uint FileOffset=R[6];
 
 				if (DataSize>=VM_GLOBALMEMADDR || DataSize<4)
@@ -906,8 +910,8 @@ void RarVM::ExecuteStandardFilter(VM_StandardFilters FilterType)
 					if (CurByte==0xe8 || CurByte==CmpByte2)
 					{
 #ifdef PRESENT_INT32
-            sint32 Offset=CurPos+FileOffset;
+            sint32 Offset=(sint32)(CurPos+FileOffset);
-            sint32 Addr=GET_VALUE(false,Data);
+            sint32 Addr=(sint32)(GET_VALUE(false,Data));
             if (Addr<0)
             {
               if (Addr+Offset>=0)
@@ -937,7 +941,7 @@ void RarVM::ExecuteStandardFilter(VM_StandardFilters FilterType)
 		case VMSF_ITANIUM:
 			{
 				byte *Data=Mem;
-				int DataSize=R[4];
+				long DataSize=R[4];
 				uint FileOffset=R[6];
 
 				if (DataSize>=VM_GLOBALMEMADDR || DataSize<21)
@@ -976,7 +980,7 @@ void RarVM::ExecuteStandardFilter(VM_StandardFilters FilterType)
 			break;
 		case VMSF_DELTA:
 			{
-				int DataSize=R[4],Channels=R[0],SrcPos=0,Border=DataSize*2;
+				long DataSize=R[4],Channels=R[0],SrcPos=0,Border=DataSize*2;
 				SET_VALUE(false,&Mem[VM_GLOBALMEMADDR+0x20],DataSize);
 				if (DataSize>=VM_GLOBALMEMADDR/2)
 					break;
@@ -986,14 +990,14 @@ void RarVM::ExecuteStandardFilter(VM_StandardFilters FilterType)
 				for (int CurChannel=0;CurChannel<Channels;CurChannel++)
 				{
 					byte PrevByte=0;
-					for (int DestPos=DataSize+CurChannel;DestPos<Border;DestPos+=Channels)
+					for (long DestPos=DataSize+CurChannel;DestPos<Border;DestPos+=Channels)
 						Mem[DestPos]=(PrevByte-=Mem[SrcPos++]);
 				}
 			}
 			break;
 		case VMSF_RGB:
 			{
-				int DataSize=R[4],Width=R[0]-3,PosR=R[1];
+				long DataSize=R[4],Width=R[0]-3,PosR=R[1];
 				byte *SrcData=Mem,*DestData=SrcData+DataSize;
 				const int Channels=3;
 				SET_VALUE(false,&Mem[VM_GLOBALMEMADDR+0x20],DataSize);
@@ -1006,7 +1010,7 @@ void RarVM::ExecuteStandardFilter(VM_StandardFilters FilterType)
 					for (int I=CurChannel;I<DataSize;I+=Channels)
 					{
 						unsigned int Predicted;
-						int UpperPos=I-Width;
+						long UpperPos=I-Width;
 						if (UpperPos>=3)
 						{
 							byte *UpperData=DestData+UpperPos;
@@ -1029,7 +1033,7 @@ void RarVM::ExecuteStandardFilter(VM_StandardFilters FilterType)
 						DestData[I]=PrevByte=(byte)(Predicted-*(SrcData++));
 					}
 				}
-				for (int I=PosR,Border=DataSize-2;I<Border;I+=3)
+				for (long I=PosR,Border=DataSize-2;I<Border;I+=3)
 				{
 					byte G=DestData[I+1];
 					DestData[I]+=G;
@@ -1039,7 +1043,7 @@ void RarVM::ExecuteStandardFilter(VM_StandardFilters FilterType)
 			break;
 		case VMSF_AUDIO:
 			{
-				int DataSize=R[4],Channels=R[0];
+				long DataSize=R[4],Channels=R[0];
 				byte *SrcData=Mem,*DestData=SrcData+DataSize;
 				SET_VALUE(false,&Mem[VM_GLOBALMEMADDR+0x20],DataSize);
 				if (DataSize>=VM_GLOBALMEMADDR/2)
@@ -1106,7 +1110,7 @@ void RarVM::ExecuteStandardFilter(VM_StandardFilters FilterType)
 			break;
 		case VMSF_UPCASE:
 			{
-				int DataSize=R[4],SrcPos=0,DestPos=DataSize;
+				long DataSize=R[4],SrcPos=0,DestPos=DataSize;
 				if (DataSize>=VM_GLOBALMEMADDR/2)
 					break;
 				while (SrcPos<DataSize)
@@ -1120,6 +1124,8 @@ void RarVM::ExecuteStandardFilter(VM_StandardFilters FilterType)
 				SET_VALUE(false,&Mem[VM_GLOBALMEMADDR+0x20],DataSize);
 			}
 			break;
+            
+        default: break;
 	}
 }
 
@@ -1128,7 +1134,7 @@ unsigned int RarVM::FilterItanium_GetBits(byte *Data,int BitPos,int BitCount)
 {
 	int InAddr=BitPos/8;
 	int InBit=BitPos&7;
-	unsigned int BitField=(uint)Data[InAddr++];
+	uint BitField=(uint)Data[InAddr++];
 	BitField|=(uint)Data[InAddr++] << 8;
 	BitField|=(uint)Data[InAddr++] << 16;
 	BitField|=(uint)Data[InAddr] << 24;

Frameworks/File_Extractor/File_Extractor/unrar/rarvm.hpp

@@ -71,7 +71,7 @@ struct VM_PreparedProgram
 	uint InitR[7];
 
 	byte *FilteredData;
-	unsigned int FilteredDataSize;
+	uint FilteredDataSize;
 };
 
 class RarVM:private BitInput
@@ -84,9 +84,9 @@ class RarVM:private BitInput
 #ifdef VM_OPTIMIZE
 		void Optimize(VM_PreparedProgram *Prg);
 #endif
-		bool ExecuteCode(VM_PreparedCommand *PreparedCode,int CodeSize);
+		bool ExecuteCode(VM_PreparedCommand *PreparedCode,long CodeSize);
 #ifdef VM_STANDARDFILTERS
-		VM_StandardFilters IsStandardFilter(byte *Code,int CodeSize);
+		VM_StandardFilters IsStandardFilter(byte *Code,long CodeSize);
 		void ExecuteStandardFilter(VM_StandardFilters FilterType);
 		unsigned int FilterItanium_GetBits(byte *Data,int BitPos,int BitCount);
 		void FilterItanium_SetBits(byte *Data,unsigned int BitField,int BitPos,
@@ -102,10 +102,10 @@ class RarVM:private BitInput
 		void Init();
 		void handle_mem_error( Rar_Error_Handler& );
 		friend class Unpack;
-		void Prepare(byte *Code,int CodeSize,VM_PreparedProgram *Prg);
+		void Prepare(byte *Code,long CodeSize,VM_PreparedProgram *Prg);
 		void Execute(VM_PreparedProgram *Prg);
 		void SetLowEndianValue(uint *Addr,uint Value);
-		void SetMemory(unsigned int Pos,byte *Data,unsigned int DataSize);
+		void SetMemory(uint Pos,byte *Data,uint DataSize);
 		static uint ReadData(BitInput &Inp);
 };
 

Frameworks/File_Extractor/File_Extractor/unrar/rawread.cpp

@@ -14,7 +14,7 @@ void RawRead::Reset()
 	Data.Reset();
 }
 
-void RawRead::Read(int Size)
+void RawRead::Read(long Size)
 {
 	// (removed decryption)
 	if (Size!=0)

Frameworks/File_Extractor/File_Extractor/unrar/rawread.hpp

@@ -6,20 +6,20 @@ class RawRead
 private:
 	Array<byte> Data;
 	File *SrcFile;
-	int DataSize;
+	long DataSize;
-	int ReadPos;
+	long ReadPos;
 	friend class Archive;
 public:
 	RawRead(File *SrcFile);
 	void Reset();
-	void Read(int Size);
+	void Read(long Size);
 	void Get(byte &Field);
 	void Get(ushort &Field);
 	void Get(uint &Field);
 	void Get(byte *Field,int Size);
 	uint GetCRC(bool ProcessedOnly);
-	int Size() {return DataSize;}
+	long Size() {return DataSize;}
-    int PaddedSize() {return Data.Size()-DataSize;}
+    long PaddedSize() {return Data.Size()-DataSize;}
 };
 
 #endif

Frameworks/File_Extractor/File_Extractor/unrar/suballoc.cpp

@@ -19,14 +19,14 @@ void SubAllocator::Clean()
 }
 
 
-inline void SubAllocator::InsertNode(void* p,int indx)
+inline void SubAllocator::InsertNode(void* p,long indx)
 {
 	((RAR_NODE*) p)->next=FreeList[indx].next;
 	FreeList[indx].next=(RAR_NODE*) p;
 }
 
 
-inline void* SubAllocator::RemoveNode(int indx)
+inline void* SubAllocator::RemoveNode(long indx)
 {
 	RAR_NODE* RetVal=FreeList[indx].next;
 	FreeList[indx].next=RetVal->next;
@@ -34,7 +34,7 @@ inline void* SubAllocator::RemoveNode(int indx)
 }
 
 
-inline uint SubAllocator::U2B(int NU)
+inline uint SubAllocator::U2B(long NU)
 {
 	return /*8*NU+4*NU*/UNIT_SIZE*NU;
 }
@@ -44,13 +44,13 @@ inline uint SubAllocator::U2B(int NU)
    calculate RAR_MEM_BLK + Items address. Real RAR_MEM_BLK size must be
    equal to UNIT_SIZE, so we cannot just add Items to RAR_MEM_BLK address
 */
-inline RAR_MEM_BLK* SubAllocator::MBPtr(RAR_MEM_BLK *BasePtr,int Items)
+inline RAR_MEM_BLK* SubAllocator::MBPtr(RAR_MEM_BLK *BasePtr,long Items)
 {
   return((RAR_MEM_BLK*)( ((byte *)(BasePtr))+U2B(Items) ));
 }
 
 
-inline void SubAllocator::SplitBlock(void* pv,int OldIndx,int NewIndx)
+inline void SubAllocator::SplitBlock(void* pv,long OldIndx,long NewIndx)
 {
 	int i, UDiff=Indx2Units[OldIndx]-Indx2Units[NewIndx];
 	byte* p=((byte*) pv)+U2B(Indx2Units[NewIndx]);
@@ -76,7 +76,7 @@ void SubAllocator::StopSubAllocator()
 }
 
 
-bool SubAllocator::StartSubAllocator(int SASize)
+bool SubAllocator::StartSubAllocator(long SASize)
 {
 	uint t=SASize << 20;
 	if (SubAllocatorSize == t)
@@ -163,7 +163,7 @@ inline void SubAllocator::GlueFreeBlocks()
 	}
 }
 
-void* SubAllocator::AllocUnitsRare(int indx)
+void* SubAllocator::AllocUnitsRare(long indx)
 {
 	if ( !GlueCount )
 	{
@@ -172,7 +172,7 @@ void* SubAllocator::AllocUnitsRare(int indx)
 		if ( FreeList[indx].next )
 			return RemoveNode(indx);
 	}
-	int i=indx;
+	long i=indx;
 	do
 	{
 		if (++i == N_INDEXES)
@@ -195,7 +195,7 @@ void* SubAllocator::AllocUnitsRare(int indx)
 }
 
 
-inline void* SubAllocator::AllocUnits(int NU)
+inline void* SubAllocator::AllocUnits(long NU)
 {
 	int indx=Units2Indx[NU-1];
 	if ( FreeList[indx].next )
@@ -219,7 +219,7 @@ void* SubAllocator::AllocContext()
 }
 
 
-void* SubAllocator::ExpandUnits(void* OldPtr,int OldNU)
+void* SubAllocator::ExpandUnits(void* OldPtr,long OldNU)
 {
 	int i0=Units2Indx[OldNU-1], i1=Units2Indx[OldNU-1+1];
 	if (i0 == i1)
@@ -234,7 +234,7 @@ void* SubAllocator::ExpandUnits(void* OldPtr,int OldNU)
 }
 
 
-void* SubAllocator::ShrinkUnits(void* OldPtr,int OldNU,int NewNU)
+void* SubAllocator::ShrinkUnits(void* OldPtr,long OldNU,long NewNU)
 {
 	int i0=Units2Indx[OldNU-1], i1=Units2Indx[NewNU-1];
 	if (i0 == i1)
@@ -254,7 +254,7 @@ void* SubAllocator::ShrinkUnits(void* OldPtr,int OldNU,int NewNU)
 }
 
 
-void SubAllocator::FreeUnits(void* ptr,int OldNU)
+void SubAllocator::FreeUnits(void* ptr,long OldNU)
 {
 	InsertNode(ptr,Units2Indx[OldNU-1]);
 }

Frameworks/File_Extractor/File_Extractor/unrar/suballoc.hpp

@@ -53,14 +53,14 @@ struct RAR_NODE
 class SubAllocator
 {
 	private:
-		inline void InsertNode(void* p,int indx);
+		inline void InsertNode(void* p,long indx);
-		inline void* RemoveNode(int indx);
+		inline void* RemoveNode(long indx);
-		inline uint U2B(int NU);
+		inline uint U2B(long NU);
-		inline void SplitBlock(void* pv,int OldIndx,int NewIndx);
+		inline void SplitBlock(void* pv,long OldIndx,long NewIndx);
 		uint GetUsedMemory();
 		inline void GlueFreeBlocks();
-		void* AllocUnitsRare(int indx);
+		void* AllocUnitsRare(long indx);
-		inline RAR_MEM_BLK* MBPtr(RAR_MEM_BLK *BasePtr,int Items);
+		inline RAR_MEM_BLK* MBPtr(RAR_MEM_BLK *BasePtr,long Items);
 
 		long SubAllocatorSize;
 		byte Indx2Units[N_INDEXES], Units2Indx[128], GlueCount;
@@ -71,14 +71,14 @@ class SubAllocator
 		SubAllocator();
 		~SubAllocator() {StopSubAllocator();}
 		void Clean();
-		bool StartSubAllocator(int SASize);
+		bool StartSubAllocator(long SASize);
 		void StopSubAllocator();
 		void  InitSubAllocator();
 		inline void* AllocContext();
-		inline void* AllocUnits(int NU);
+		inline void* AllocUnits(long NU);
-		inline void* ExpandUnits(void* ptr,int OldNU);
+		inline void* ExpandUnits(void* ptr,long OldNU);
-		inline void* ShrinkUnits(void* ptr,int OldNU,int NewNU);
+		inline void* ShrinkUnits(void* ptr,long OldNU,long NewNU);
-		inline void  FreeUnits(void* ptr,int OldNU);
+		inline void  FreeUnits(void* ptr,long OldNU);
 		long GetAllocatedMemory() {return(SubAllocatorSize);};
 
 		byte *pText, *UnitsStart,*HeapEnd,*FakeUnitsStart;

Frameworks/File_Extractor/File_Extractor/unrar/unpack.cpp

@@ -78,7 +78,7 @@ void Unpack::DoUnpack(int Method,bool Solid)
 }
 
 
-inline void Unpack::InsertOldDist(unsigned int Distance)
+inline void Unpack::InsertOldDist(uint Distance)
 {
 	OldDist[3]=OldDist[2];
 	OldDist[2]=OldDist[1];
@@ -87,7 +87,7 @@ inline void Unpack::InsertOldDist(unsigned int Distance)
 }
 
 
-inline void Unpack::InsertLastMatch(unsigned int Length,unsigned int Distance)
+inline void Unpack::InsertLastMatch(uint Length,uint Distance)
 {
 	LastDist=Distance;
 	LastLength=Length;
@@ -95,12 +95,12 @@ inline void Unpack::InsertLastMatch(unsigned int Length,unsigned int Distance)
 
 
 // These optimizations give 22% speedup on x86, 44% speedup on PowerPC
-void Unpack::CopyString(unsigned int Length,unsigned int Distance)
+void Unpack::CopyString(uint Length,uint Distance)
 {
-	unsigned    UnpPtr = this->UnpPtr; // cache in register
+	uint        UnpPtr = this->UnpPtr; // cache in register
 	byte* const Window = this->Window; // cache in register
 
-	unsigned int DestPtr=UnpPtr-Distance;
+	uint DestPtr=UnpPtr-Distance;
 	if (UnpPtr<MAXWINSIZE-260 && DestPtr<MAXWINSIZE-260)
 	{
 		this->UnpPtr += Length;
@@ -132,7 +132,7 @@ void Unpack::CopyString(unsigned int Length,unsigned int Distance)
 }
 
 
-int Unpack::DecodeNumber(struct Decode *Dec)
+long Unpack::DecodeNumber(struct Decode *Dec)
 {
 	unsigned int Bits;
 	unsigned int BitField=getbits() & 0xfffe;
@@ -180,7 +180,7 @@ int Unpack::DecodeNumber(struct Decode *Dec)
 			else
 				Bits=15;
 
-	unsigned int N=Dec->DecodePos[Bits]+((BitField-Dec->DecodeLen[Bits-1])>>(16-Bits));
+	uint N=Dec->DecodePos[Bits]+((BitField-Dec->DecodeLen[Bits-1])>>(16-Bits));
 	if (N>=Dec->MaxNum)
 		N=0;
 	// do after reading values, to allow better instruction scheduling
@@ -320,7 +320,7 @@ void Unpack::Unpack29(bool Solid)
 			continue;
 		}
 
-		int Number=DecodeNumber((struct Decode *)&LD);
+		long Number=DecodeNumber((struct Decode *)&LD);
 		if (Number<256)
 		{
 			Window[UnpPtr++]=(byte)Number;
@@ -335,8 +335,8 @@ void Unpack::Unpack29(bool Solid)
 				addbits(Bits);
 			}
 
-			int DistNumber=DecodeNumber((struct Decode *)&DD);
+			long DistNumber=DecodeNumber((struct Decode *)&DD);
-			unsigned int Distance=DDecode[DistNumber]+1;
+			uint Distance=DDecode[DistNumber]+1;
 			if ((Bits=DBits[DistNumber])>0)
 			{
 				if (DistNumber>9)
@@ -353,7 +353,7 @@ void Unpack::Unpack29(bool Solid)
 					}
 					else
 					{
-						int LowDist=DecodeNumber((struct Decode *)&LDD);
+						long LowDist=DecodeNumber((struct Decode *)&LDD);
 						if (LowDist==16)
 						{
 							LowDistRepCount=LOW_DIST_REP_COUNT-1;
@@ -405,14 +405,14 @@ void Unpack::Unpack29(bool Solid)
 		}
 		if (Number<263)
 		{
-			int DistNum=Number-259;
+			long DistNum=Number-259;
-			unsigned int Distance=OldDist[DistNum];
+			uint Distance=OldDist[DistNum];
-			for (int I=DistNum;I>0;I--)
+			for (long I=DistNum;I>0;I--)
 				OldDist[I]=OldDist[I-1];
 			OldDist[0]=Distance;
 
-			int LengthNumber=DecodeNumber((struct Decode *)&RD);
+			long LengthNumber=DecodeNumber((struct Decode *)&RD);
-			int Length=LDecode[LengthNumber]+2;
+			long Length=LDecode[LengthNumber]+2;
 			if ((Bits=LBits[LengthNumber])>0)
 			{
 				Length+=getbits()>>(16-Bits);
@@ -456,7 +456,7 @@ bool Unpack::ReadEndOfBlock()
 		addbits(2);
 	}
 	TablesRead=!NewTable;
-	return !(NewFile || NewTable && !ReadTables());
+	return !(NewFile || (NewTable && !ReadTables()));
 }
 
 
@@ -524,7 +524,7 @@ bool Unpack::ReadVMCodePPM()
 }
 
 
-bool Unpack::AddVMCode(unsigned int FirstByte,byte *Code,int CodeSize)
+bool Unpack::AddVMCode(uint FirstByte,byte *Code,long CodeSize)
 {
 	// TODO: auto clear object to free bit input on normal return?
 	Inp.InitBitInput();
@@ -595,7 +595,7 @@ bool Unpack::AddVMCode(unsigned int FirstByte,byte *Code,int CodeSize)
 		PrgStack.Add(1);
 		EmptyCount=1;
 	}
-	int StackPos=PrgStack.Size()-EmptyCount;
+	long StackPos=PrgStack.Size()-EmptyCount;
 	PrgStack[StackPos]=StackFilter;
 	LastStackFilter = NULL;
 	StackFilter->ExecCount=Filter->ExecCount;
@@ -647,7 +647,7 @@ bool Unpack::AddVMCode(unsigned int FirstByte,byte *Code,int CodeSize)
 	StackFilter->Prg.AltCmd=&Filter->Prg.Cmd[0];
 	StackFilter->Prg.CmdCount=Filter->Prg.CmdCount;
 
-	int StaticDataSize=Filter->Prg.StaticData.Size();
+	long StaticDataSize=Filter->Prg.StaticData.Size();
 	if (StaticDataSize>0 && StaticDataSize<VM_GLOBALMEMSIZE)
 	{
 		// read statically defined data contained in DB commands
@@ -675,7 +675,7 @@ bool Unpack::AddVMCode(unsigned int FirstByte,byte *Code,int CodeSize)
 		uint DataSize=RarVM::ReadData(Inp);
 		if (DataSize>VM_GLOBALMEMSIZE-VM_FIXEDGLOBALSIZE)
 			return(false);
-		unsigned int CurSize=StackFilter->Prg.GlobalData.Size();
+		uint CurSize=StackFilter->Prg.GlobalData.Size();
 		if (CurSize<DataSize+VM_FIXEDGLOBALSIZE)
 			StackFilter->Prg.GlobalData.Add(DataSize+VM_FIXEDGLOBALSIZE-CurSize);
 		byte *GlobalData=&StackFilter->Prg.GlobalData[VM_FIXEDGLOBALSIZE];
@@ -694,7 +694,7 @@ bool Unpack::AddVMCode(unsigned int FirstByte,byte *Code,int CodeSize)
 
 bool Unpack::UnpReadBuf()
 {
-	int DataSize=ReadTop-InAddr;
+	long DataSize=ReadTop-InAddr;
 	if (DataSize<0)
 		return(false);
 	if (InAddr>BitInput::MAX_SIZE/2)
@@ -706,7 +706,7 @@ bool Unpack::UnpReadBuf()
 	}
 	else
 		DataSize=ReadTop;
-	int ReadCode=UnpIO->UnpRead(InBuf+DataSize,(BitInput::MAX_SIZE-DataSize)&~0xf);
+	long ReadCode=UnpIO->UnpRead(InBuf+DataSize,(BitInput::MAX_SIZE-DataSize)&~0xf);
 	if (ReadCode>0)
 		ReadTop+=ReadCode;
 	ReadBorder=ReadTop-30;
@@ -716,8 +716,8 @@ bool Unpack::UnpReadBuf()
 
 void Unpack::UnpWriteBuf()
 {
-	unsigned int WrittenBorder=WrPtr;
+	uint WrittenBorder=WrPtr;
-	unsigned int WriteSize=(UnpPtr-WrittenBorder)&MAXWINMASK;
+	uint WriteSize=(UnpPtr-WrittenBorder)&MAXWINMASK;
 	for (int I=0;I<PrgStack.Size();I++)
 	{
 		UnpackFilter *flt=PrgStack[I];
@@ -728,8 +728,8 @@ void Unpack::UnpWriteBuf()
 			flt->NextWindow=false;
 			continue;
 		}
-		unsigned int BlockStart=flt->BlockStart;
+		uint BlockStart=flt->BlockStart;
-		unsigned int BlockLength=flt->BlockLength;
+		uint BlockLength=flt->BlockLength;
 		if (((BlockStart-WrittenBorder)&MAXWINMASK)<WriteSize)
 		{
 			if (WrittenBorder!=BlockStart)
@@ -740,12 +740,12 @@ void Unpack::UnpWriteBuf()
 			}
 			if (BlockLength<=WriteSize)
 			{
-				unsigned int BlockEnd=(BlockStart+BlockLength)&MAXWINMASK;
+				uint BlockEnd=(BlockStart+BlockLength)&MAXWINMASK;
 				if (BlockStart<BlockEnd || BlockEnd==0)
 					VM.SetMemory(0,Window+BlockStart,BlockLength);
 				else
 				{
-					unsigned int FirstPartLength=MAXWINSIZE-BlockStart;
+					uint FirstPartLength=MAXWINSIZE-BlockStart;
 					VM.SetMemory(0,Window+BlockStart,FirstPartLength);
 					VM.SetMemory(FirstPartLength,Window,BlockEnd);
 				}
@@ -773,7 +773,7 @@ void Unpack::UnpWriteBuf()
 					ParentPrg->GlobalData.Reset();
 
 				byte *FilteredData=Prg->FilteredData;
-				unsigned int FilteredDataSize=Prg->FilteredDataSize;
+				uint FilteredDataSize=Prg->FilteredDataSize;
 
 				delete PrgStack[I];
 				PrgStack[I]=NULL;
@@ -853,7 +853,7 @@ void Unpack::ExecuteCode(VM_PreparedProgram *Prg)
 }
 
 
-void Unpack::UnpWriteArea(unsigned int StartPtr,unsigned int EndPtr)
+void Unpack::UnpWriteArea(uint StartPtr,uint EndPtr)
 {
 	if (EndPtr!=StartPtr)
 		UnpSomeRead=true;
@@ -868,11 +868,11 @@ void Unpack::UnpWriteArea(unsigned int StartPtr,unsigned int EndPtr)
 }
 
 
-void Unpack::UnpWriteData(byte *Data,int Size)
+void Unpack::UnpWriteData(byte *Data,long Size)
 {
 	if (WrittenFileSize>=DestUnpSize)
 		return;
-	int WriteSize=Size;
+	long WriteSize=Size;
 	Int64 LeftToWrite=DestUnpSize-WrittenFileSize;
 	if (WriteSize>LeftToWrite)
 		WriteSize=int64to32(LeftToWrite);
@@ -928,13 +928,13 @@ bool Unpack::ReadTables()
 	}
 	MakeDecodeTables(BitLength,(struct Decode *)&BD,BC);
 
-	const int TableSize=HUFF_TABLE_SIZE;
+	const long TableSize=HUFF_TABLE_SIZE;
-	for (int I=0;I<TableSize;)
+	for (long I=0;I<TableSize;)
 	{
 		if (InAddr>ReadTop-5)
 			if (!UnpReadBuf())
 				return(false);
-		int Number=DecodeNumber((struct Decode *)&BD);
+		long Number=DecodeNumber((struct Decode *)&BD);
 		if (Number<16)
 		{
 			Table[I]=(Number+UnpOldTable[I]) & 0xf;
@@ -1038,9 +1038,9 @@ void Unpack::InitFilters()
 }
 
 
-void Unpack::MakeDecodeTables(unsigned char *LenTab,struct Decode *Dec,int Size)
+void Unpack::MakeDecodeTables(unsigned char *LenTab,struct Decode *Dec,long Size)
 {
-	int LenCount[16],TmpPos[16],I;
+	long LenCount[16],TmpPos[16],I;
 	long M,N;
 	memset(LenCount,0,sizeof(LenCount));
 	memset(Dec->DecodeNum,0,Size*sizeof(*Dec->DecodeNum));

Frameworks/File_Extractor/File_Extractor/unrar/unpack.hpp

@@ -5,63 +5,63 @@ enum BLOCK_TYPES {BLOCK_LZ,BLOCK_PPM};
 
 struct Decode
 {
-	unsigned int MaxNum;
+	uint MaxNum;
-	unsigned int DecodeLen[16];
+	uint DecodeLen[16];
-	unsigned int DecodePos[16];
+	uint DecodePos[16];
-	unsigned int DecodeNum[2];
+	uint DecodeNum[2];
 };
 
 struct LitDecode
 {
-	unsigned int MaxNum;
+	uint MaxNum;
-	unsigned int DecodeLen[16];
+	uint DecodeLen[16];
-	unsigned int DecodePos[16];
+	uint DecodePos[16];
-	unsigned int DecodeNum[NC];
+	uint DecodeNum[NC];
 };
 
 struct DistDecode
 {
-	unsigned int MaxNum;
+	uint MaxNum;
-	unsigned int DecodeLen[16];
+	uint DecodeLen[16];
-	unsigned int DecodePos[16];
+	uint DecodePos[16];
-	unsigned int DecodeNum[DC];
+	uint DecodeNum[DC];
 };
 
 struct LowDistDecode
 {
-	unsigned int MaxNum;
+	uint MaxNum;
-	unsigned int DecodeLen[16];
+	uint DecodeLen[16];
-	unsigned int DecodePos[16];
+	uint DecodePos[16];
-	unsigned int DecodeNum[LDC];
+	uint DecodeNum[LDC];
 };
 
 struct RepDecode
 {
-	unsigned int MaxNum;
+	uint MaxNum;
-	unsigned int DecodeLen[16];
+	uint DecodeLen[16];
-	unsigned int DecodePos[16];
+	uint DecodePos[16];
-	unsigned int DecodeNum[RC];
+	uint DecodeNum[RC];
 };
 
 struct BitDecode
 {
-	unsigned int MaxNum;
+	uint MaxNum;
-	unsigned int DecodeLen[16];
+	uint DecodeLen[16];
-	unsigned int DecodePos[16];
+	uint DecodePos[16];
-	unsigned int DecodeNum[BC];
+	uint DecodeNum[BC];
 };
 
 struct UnpackFilter
 	: Rar_Allocator
 {
-	unsigned int BlockStart;
+	unsigned long BlockStart;
-	unsigned int BlockLength;
+	unsigned long BlockLength;
-	unsigned int ExecCount;
+	unsigned long ExecCount;
 	bool NextWindow;
 
 	// position of parent filter in Filters array used as prototype for filter
 	// in PrgStack array. Not defined for filters in Filters array.
-	unsigned int ParentFilter;
+	unsigned long ParentFilter;
 
 	VM_PreparedProgram Prg;
 	UnpackFilter( Rar_Error_Handler* eh ) : Prg( eh ) { }
@@ -70,10 +70,10 @@ struct UnpackFilter
 /***************************** Unpack v 2.0 *********************************/
 struct MultDecode
 {
-	unsigned int MaxNum;
+	uint MaxNum;
-	unsigned int DecodeLen[16];
+	uint DecodeLen[16];
-	unsigned int DecodePos[16];
+	uint DecodePos[16];
-	unsigned int DecodeNum[MC20];
+	uint DecodeNum[MC20];
 };
 
 struct AudioVariables
@@ -81,9 +81,9 @@ struct AudioVariables
 	int K1,K2,K3,K4,K5;
 	int D1,D2,D3,D4;
 	int LastDelta;
-	unsigned int Dif[11];
+	uint Dif[11];
-	unsigned int ByteCount;
+	uint ByteCount;
-	int LastChar;
+	long LastChar;
 };
 /***************************** Unpack v 2.0 *********************************/
 
@@ -98,20 +98,20 @@ private:
 	bool UnpReadBuf();
 	void UnpWriteBuf();
 	void ExecuteCode(VM_PreparedProgram *Prg);
-	void UnpWriteArea(unsigned int StartPtr,unsigned int EndPtr);
+	void UnpWriteArea(uint StartPtr,uint EndPtr);
-	void UnpWriteData(byte *Data,int Size);
+	void UnpWriteData(byte *Data,long Size);
 	bool ReadTables();
-	void MakeDecodeTables(unsigned char *LenTab,struct Decode *Dec,int Size);
+	void MakeDecodeTables(unsigned char *LenTab,struct Decode *Dec,long Size);
-	int DecodeNumber(struct Decode *Dec);
+	long DecodeNumber(struct Decode *Dec);
 	void CopyString();
-	inline void InsertOldDist(unsigned int Distance);
+	inline void InsertOldDist(uint Distance);
-	inline void InsertLastMatch(unsigned int Length,unsigned int Distance);
+	inline void InsertLastMatch(uint Length,uint Distance);
 	void UnpInitData(int Solid);
-	void CopyString(unsigned int Length,unsigned int Distance);
+	void CopyString(uint Length,uint Distance);
 	bool ReadEndOfBlock();
 	bool ReadVMCode();
 	bool ReadVMCodePPM();
-	bool AddVMCode(unsigned int FirstByte,byte *Code,int CodeSize);
+	bool AddVMCode(uint FirstByte,byte *Code,long CodeSize);
 	void InitFilters();
 
 	ComprDataIO *UnpIO;
@@ -133,9 +133,9 @@ private:
 
     /* lengths of preceding blocks, one length per filter. Used to reduce
        size required to write block length if lengths are repeating */
-	Array<int> OldFilterLengths;
+	Array<long> OldFilterLengths;
 
-	int LastFilter;
+	long LastFilter;
 
 	bool TablesRead;
 	struct LitDecode LD;
@@ -144,13 +144,13 @@ private:
 	struct RepDecode RD;
 	struct BitDecode BD;
 
-	unsigned int OldDist[4],OldDistPtr;
+	uint OldDist[4],OldDistPtr;
-	unsigned int LastDist,LastLength;
+	uint LastDist,LastLength;
 
-	unsigned int UnpPtr,WrPtr;
+	uint UnpPtr,WrPtr;
 
-	int ReadTop;
+	long ReadTop;
-	int ReadBorder;
+	long ReadBorder;
 
 	unsigned char UnpOldTable[HUFF_TABLE_SIZE];
 
@@ -168,7 +168,7 @@ private:
 	Int64 WrittenFileSize;
 	bool FileExtracted;
 
-	int PrevLowDist,LowDistRepCount;
+	long PrevLowDist,LowDistRepCount;
 
 	/***************************** Unpack v 1.5 *********************************/
 	void Unpack15(bool Solid);
@@ -178,18 +178,18 @@ private:
 	void GetFlagsBuf();
 	void OldUnpInitData(int Solid);
 	void InitHuff();
-	void CorrHuff(unsigned int *CharSet,unsigned int *NumToPlace);
+	void CorrHuff(uint *CharSet,uint *NumToPlace);
-	void OldCopyString(unsigned int Distance,unsigned int Length);
+	void OldCopyString(uint Distance,uint Length);
-	unsigned int DecodeNum(int Num,unsigned int StartPos,
+	uint DecodeNum(long Num,uint StartPos,
-	  const unsigned int *DecTab,const unsigned int *PosTab);
+	  const uint *DecTab,const uint *PosTab);
 	void OldUnpWriteBuf();
 
-	unsigned int ChSet[256],ChSetA[256],ChSetB[256],ChSetC[256];
+	uint ChSet[256],ChSetA[256],ChSetB[256],ChSetC[256];
-	unsigned int Place[256],PlaceA[256],PlaceB[256],PlaceC[256];
+	uint Place[256],PlaceA[256],PlaceB[256],PlaceC[256];
-	unsigned int NToPl[256],NToPlB[256],NToPlC[256];
+	uint NToPl[256],NToPlB[256],NToPlC[256];
-	unsigned int FlagBuf,AvrPlc,AvrPlcB,AvrLn1,AvrLn2,AvrLn3;
+	uint FlagBuf,AvrPlc,AvrPlcB,AvrLn1,AvrLn2,AvrLn3;
-	int Buf60,NumHuf,StMode,LCount,FlagsCnt;
+	long Buf60,NumHuf,StMode,LCount,FlagsCnt;
-	unsigned int Nhfb,Nlzb,MaxDist3;
+	uint Nhfb,Nlzb,MaxDist3;
 	/***************************** Unpack v 1.5 *********************************/
 
 	/***************************** Unpack v 2.0 *********************************/
@@ -197,11 +197,11 @@ private:
 	struct MultDecode MD[4];
 	unsigned char UnpOldTable20[MC20*4];
 	int UnpAudioBlock,UnpChannels,UnpCurChannel,UnpChannelDelta;
-	void CopyString20(unsigned int Length,unsigned int Distance);
+	void CopyString20(uint Length,uint Distance);
 	bool ReadTables20();
 	void UnpInitData20(int Solid);
 	void ReadLastTables();
-	byte DecodeAudio(int Delta);
+	byte DecodeAudio(long Delta);
 	struct AudioVariables AudV[4];
 	/***************************** Unpack v 2.0 *********************************/
 

Frameworks/File_Extractor/File_Extractor/unrar/unpack15.cpp

@@ -2,55 +2,55 @@
 #ifdef RAR_COMMON_HPP
 #define STARTL1  2
 const
-static unsigned int DecL1[]={0x8000,0xa000,0xc000,0xd000,0xe000,0xea00,
+static uint DecL1[]={0x8000,0xa000,0xc000,0xd000,0xe000,0xea00,
 														 0xee00,0xf000,0xf200,0xf200,0xffff};
 const
-static unsigned int PosL1[]={0,0,0,2,3,5,7,11,16,20,24,32,32};
+static uint PosL1[]={0,0,0,2,3,5,7,11,16,20,24,32,32};
 
 #define STARTL2  3
 const
-static unsigned int DecL2[]={0xa000,0xc000,0xd000,0xe000,0xea00,0xee00,
+static uint DecL2[]={0xa000,0xc000,0xd000,0xe000,0xea00,0xee00,
 														 0xf000,0xf200,0xf240,0xffff};
 const
-static unsigned int PosL2[]={0,0,0,0,5,7,9,13,18,22,26,34,36};
+static uint PosL2[]={0,0,0,0,5,7,9,13,18,22,26,34,36};
 
 #define STARTHF0  4
 const
-static unsigned int DecHf0[]={0x8000,0xc000,0xe000,0xf200,0xf200,0xf200,
+static uint DecHf0[]={0x8000,0xc000,0xe000,0xf200,0xf200,0xf200,
 															0xf200,0xf200,0xffff};
 const
-static unsigned int PosHf0[]={0,0,0,0,0,8,16,24,33,33,33,33,33};
+static uint PosHf0[]={0,0,0,0,0,8,16,24,33,33,33,33,33};
 
 
 #define STARTHF1  5
 const
-static unsigned int DecHf1[]={0x2000,0xc000,0xe000,0xf000,0xf200,0xf200,
+static uint DecHf1[]={0x2000,0xc000,0xe000,0xf000,0xf200,0xf200,
 															0xf7e0,0xffff};
 const
-static unsigned int PosHf1[]={0,0,0,0,0,0,4,44,60,76,80,80,127};
+static uint PosHf1[]={0,0,0,0,0,0,4,44,60,76,80,80,127};
 
 
 #define STARTHF2  5
 const
-static unsigned int DecHf2[]={0x1000,0x2400,0x8000,0xc000,0xfa00,0xffff,
+static uint DecHf2[]={0x1000,0x2400,0x8000,0xc000,0xfa00,0xffff,
 															0xffff,0xffff};
 const
-static unsigned int PosHf2[]={0,0,0,0,0,0,2,7,53,117,233,0,0};
+static uint PosHf2[]={0,0,0,0,0,0,2,7,53,117,233,0,0};
 
 
 #define STARTHF3  6
 const
-static unsigned int DecHf3[]={0x800,0x2400,0xee00,0xfe80,0xffff,0xffff,
+static uint DecHf3[]={0x800,0x2400,0xee00,0xfe80,0xffff,0xffff,
 															0xffff};
 const
-static unsigned int PosHf3[]={0,0,0,0,0,0,0,2,16,218,251,0,0};
+static uint PosHf3[]={0,0,0,0,0,0,0,2,16,218,251,0,0};
 
 
 #define STARTHF4  8
 const
-static unsigned int DecHf4[]={0xff00,0xffff,0xffff,0xffff,0xffff,0xffff};
+static uint DecHf4[]={0xff00,0xffff,0xffff,0xffff,0xffff,0xffff};
 const
-static unsigned int PosHf4[]={0,0,0,0,0,0,0,0,0,255,0,0,0};
+static uint PosHf4[]={0,0,0,0,0,0,0,0,0,255,0,0,0};
 
 
 void Unpack::Unpack15(bool Solid)
@@ -158,21 +158,21 @@ void Unpack::OldUnpWriteBuf()
 void Unpack::ShortLZ()
 {
 	const
-	static unsigned int ShortLen1[]={1,3,4,4,5,6,7,8,8,4,4,5,6,6,4,0};
+	static uint ShortLen1[]={1,3,4,4,5,6,7,8,8,4,4,5,6,6,4,0};
 	const
-	static unsigned int ShortXor1[]={0,0xa0,0xd0,0xe0,0xf0,0xf8,0xfc,0xfe,
+	static uint ShortXor1[]={0,0xa0,0xd0,0xe0,0xf0,0xf8,0xfc,0xfe,
 																	 0xff,0xc0,0x80,0x90,0x98,0x9c,0xb0};
 	const
-	static unsigned int ShortLen2[]={2,3,3,3,4,4,5,6,6,4,4,5,6,6,4,0};
+	static uint ShortLen2[]={2,3,3,3,4,4,5,6,6,4,4,5,6,6,4,0};
 	const
-	static unsigned int ShortXor2[]={0,0x40,0x60,0xa0,0xd0,0xe0,0xf0,0xf8,
+	static uint ShortXor2[]={0,0x40,0x60,0xa0,0xd0,0xe0,0xf0,0xf8,
 																	 0xfc,0xc0,0x80,0x90,0x98,0x9c,0xb0};
 
 
-	unsigned int Length,SaveLength;
+	uint Length,SaveLength;
-	unsigned int LastDistance;
+	uint LastDistance;
-	unsigned int Distance;
+	uint Distance;
-	int DistancePlace;
+	long DistancePlace;
 	NumHuf=0;
 
 	unsigned int BitField=fgetbits();
@@ -181,7 +181,7 @@ void Unpack::ShortLZ()
 		faddbits(1);
 		if (BitField >= 0x8000)
 		{
-			OldCopyString((unsigned int)LastDist,LastLength);
+			OldCopyString((uint)LastDist,LastLength);
 			return;
 		}
 		BitField <<= 1;
@@ -275,10 +275,10 @@ void Unpack::ShortLZ()
 
 void Unpack::LongLZ()
 {
-	unsigned int Length;
+	uint Length;
-	unsigned int Distance;
+	uint Distance;
-	unsigned int DistancePlace,NewDistancePlace;
+	uint DistancePlace,NewDistancePlace;
-	unsigned int OldAvr2,OldAvr3;
+	uint OldAvr2,OldAvr3;
 
 	NumHuf=0;
 	Nlzb+=16;
@@ -340,6 +340,7 @@ void Unpack::LongLZ()
 
 	OldAvr3=AvrLn3;
 	if (Length!=1 && Length!=4)
+    {
 		if (Length==0 && Distance <= MaxDist3)
 		{
 			AvrLn3++;
@@ -348,12 +349,13 @@ void Unpack::LongLZ()
 		else
 			if (AvrLn3 > 0)
 				AvrLn3--;
+    }
 	Length+=3;
 	if (Distance >= MaxDist3)
 		Length++;
 	if (Distance <= 256)
 		Length+=8;
-	if (OldAvr3 > 0xb0 || AvrPlc >= 0x2a00 && OldAvr2 < 0x40)
+	if (OldAvr3 > 0xb0 || (AvrPlc >= 0x2a00 && OldAvr2 < 0x40))
 		MaxDist3=0x7f00;
 	else
 		MaxDist3=0x2001;
@@ -367,10 +369,10 @@ void Unpack::LongLZ()
 
 void Unpack::HuffDecode()
 {
-	unsigned int CurByte,NewBytePlace;
+	uint CurByte,NewBytePlace;
-	unsigned int Length;
+	uint Length;
-	unsigned int Distance;
+	uint Distance;
-	int BytePlace;
+	long BytePlace;
 
 	unsigned int BitField=fgetbits();
 
@@ -445,8 +447,8 @@ void Unpack::HuffDecode()
 
 void Unpack::GetFlagsBuf()
 {
-	unsigned int Flags,NewFlagsPlace;
+	uint Flags,NewFlagsPlace;
-	unsigned int FlagsPlace=DecodeNum(fgetbits(),STARTHF2,DecHf2,PosHf2);
+	uint FlagsPlace=DecodeNum(fgetbits(),STARTHF2,DecHf2,PosHf2);
 
 	while (1)
 	{
@@ -497,7 +499,7 @@ void Unpack::InitHuff()
 }
 
 
-void Unpack::CorrHuff(unsigned int *CharSet,unsigned int *NumToPlace)
+void Unpack::CorrHuff(uint *CharSet,uint *NumToPlace)
 {
 	int I,J;
 	for (I=7;I>=0;I--)
@@ -509,7 +511,7 @@ void Unpack::CorrHuff(unsigned int *CharSet,unsigned int *NumToPlace)
 }
 
 
-void Unpack::OldCopyString(unsigned int Distance,unsigned int Length)
+void Unpack::OldCopyString(uint Distance,uint Length)
 {
 	DestUnpSize-=Length;
 	while (Length--)
@@ -520,10 +522,10 @@ void Unpack::OldCopyString(unsigned int Distance,unsigned int Length)
 }
 
 
-unsigned int Unpack::DecodeNum(int Num,unsigned int StartPos,
+uint Unpack::DecodeNum(long Num,uint StartPos,
-			const unsigned int *DecTab,const unsigned int *PosTab)
+			const uint *DecTab,const uint *PosTab)
 {
-	int I;
+	long I;
 	for (Num&=0xfff0,I=0;DecTab[I]<=Num;I++)
 		StartPos++;
 	faddbits(StartPos);

Frameworks/File_Extractor/File_Extractor/unrar/unpack20.cpp

@@ -3,16 +3,16 @@
 #include "rar.hpp"
 
 // Presumably these optimizations give similar speedup as those for CopyString in unpack.cpp
-void Unpack::CopyString20(unsigned int Length,unsigned int Distance)
+void Unpack::CopyString20(uint Length,uint Distance)
 {
 	LastDist=OldDist[OldDistPtr++ & 3]=Distance;
 	LastLength=Length;
 	DestUnpSize-=Length;
 
-	unsigned    UnpPtr = this->UnpPtr; // cache in register
+	uint        UnpPtr = this->UnpPtr; // cache in register
 	byte* const Window = this->Window; // cache in register
 	
-	unsigned int DestPtr=UnpPtr-Distance;
+	uint DestPtr=UnpPtr-Distance;
 	if (UnpPtr<MAXWINSIZE-300 && DestPtr<MAXWINSIZE-300)
 	{
 		this->UnpPtr += Length;
@@ -87,7 +87,7 @@ void Unpack::Unpack20(bool Solid)
 		}
 		if (UnpAudioBlock)
 		{
-			int AudioNumber=DecodeNumber((struct Decode *)&MD[UnpCurChannel]);
+			long AudioNumber=DecodeNumber((struct Decode *)&MD[UnpCurChannel]);
 
 			if (AudioNumber==256)
 			{
@@ -102,7 +102,7 @@ void Unpack::Unpack20(bool Solid)
 			continue;
 		}
 
-		int Number=DecodeNumber((struct Decode *)&LD);
+		long Number=DecodeNumber((struct Decode *)&LD);
 		if (Number<256)
 		{
 			Window[UnpPtr++]=(byte)Number;
@@ -118,8 +118,8 @@ void Unpack::Unpack20(bool Solid)
 				addbits(Bits);
 			}
 
-			int DistNumber=DecodeNumber((struct Decode *)&DD);
+			long DistNumber=DecodeNumber((struct Decode *)&DD);
-			unsigned int Distance=DDecode[DistNumber]+1;
+			uint Distance=DDecode[DistNumber]+1;
 			if ((Bits=DBits[DistNumber])>0)
 			{
 				Distance+=getbits()>>(16-Bits);
@@ -149,9 +149,9 @@ void Unpack::Unpack20(bool Solid)
 		}
 		if (Number<261)
 		{
-			unsigned int Distance=OldDist[(OldDistPtr-(Number-256)) & 3];
+			uint Distance=OldDist[(OldDistPtr-(Number-256)) & 3];
-			int LengthNumber=DecodeNumber((struct Decode *)&RD);
+			long LengthNumber=DecodeNumber((struct Decode *)&RD);
-			int Length=LDecode[LengthNumber]+2;
+			long Length=LDecode[LengthNumber]+2;
 			if ((Bits=LBits[LengthNumber])>0)
 			{
 				Length+=getbits()>>(16-Bits);
@@ -225,7 +225,7 @@ bool Unpack::ReadTables20()
 		if (InAddr>ReadTop-5)
 			if (!UnpReadBuf())
 				return(false);
-		int Number=DecodeNumber((struct Decode *)&BD);
+		long Number=DecodeNumber((struct Decode *)&BD);
 		if (Number<16)
 		{
 			Table[I]=(Number+UnpOldTable20[I]) & 0xf;
@@ -277,6 +277,7 @@ bool Unpack::ReadTables20()
 void Unpack::ReadLastTables()
 {
 	if (ReadTop>=InAddr+5)
+    {
 		if (UnpAudioBlock)
 		{
 			if (DecodeNumber((struct Decode *)&MD[UnpCurChannel])==256)
@@ -285,6 +286,7 @@ void Unpack::ReadLastTables()
 		else
 			if (DecodeNumber((struct Decode *)&LD)==269)
 				ReadTables20();
+    }
 }
 
 
@@ -302,7 +304,7 @@ void Unpack::UnpInitData20(int Solid)
 }
 
 
-byte Unpack::DecodeAudio(int Delta)
+byte Unpack::DecodeAudio(long Delta)
 {
 	struct AudioVariables *V=&AudV[UnpCurChannel];
 	V->ByteCount++;
@@ -310,10 +312,10 @@ byte Unpack::DecodeAudio(int Delta)
 	V->D3=V->D2;
 	V->D2=V->LastDelta-V->D1;
 	V->D1=V->LastDelta;
-	int PCh=8*V->LastChar+V->K1*V->D1+V->K2*V->D2+V->K3*V->D3+V->K4*V->D4+V->K5*UnpChannelDelta;
+	long PCh=8*V->LastChar+V->K1*V->D1+V->K2*V->D2+V->K3*V->D3+V->K4*V->D4+V->K5*UnpChannelDelta;
 	PCh=(PCh>>3) & 0xFF;
 
-	unsigned int Ch=PCh-Delta;
+	uint Ch=PCh-Delta;
 
 	int D=((signed char)Delta)<<3;
 
@@ -334,9 +336,9 @@ byte Unpack::DecodeAudio(int Delta)
 
 	if ((V->ByteCount & 0x1F)==0)
 	{
-		unsigned int MinDif=V->Dif[0],NumMinDif=0;
+		uint MinDif=V->Dif[0],NumMinDif=0;
 		V->Dif[0]=0;
-		for (int I=1;I<sizeof(V->Dif)/sizeof(V->Dif[0]);I++)
+		for (long I=1;I<sizeof(V->Dif)/sizeof(V->Dif[0]);I++)
 		{
 			if (V->Dif[I]<MinDif)
 			{

Frameworks/File_Extractor/File_Extractor/unrar/unrar.cpp

@@ -147,8 +147,8 @@ static unrar_err_t next_( unrar_t* p, bool skipping_solid )
 		if ( type != FILE_HEAD )
 		{
 			// Skip non-files
-			if ( type != NEWSUB_HEAD && type != PROTECT_HEAD && type != SIGN_HEAD && type != SUB_HEAD )
+			/*if ( type != NEWSUB_HEAD && type != PROTECT_HEAD && type != SIGN_HEAD && type != SUB_HEAD )
-				debug_printf( "unrar: Skipping unknown block type: %X\n", (unsigned) type );
+				debug_printf( "unrar: Skipping unknown block type: %X\n", (unsigned) type );*/
 			
 			update_solid_pos( p );
 		}

Frameworks/File_Extractor/File_Extractor/unrar/unrar.h

@@ -37,6 +37,10 @@ typedef unrar_long_long unrar_pos_t;
 /** Boolean, where 0 is false and 1 is true */
 typedef int unrar_bool;
 
+typedef unsigned char    byte;   //8 bits
+typedef unsigned short   ushort; //preferably 16 bits, but can be more
+typedef unsigned long    uint;   //32 bits or more
+        
 
 /******** Open/close ********/
 
@@ -53,7 +57,7 @@ file at offset pos and set *count to avail, where avail is the lesser of *count
 and file_size-pos. Put read bytes into *out and return unrar_ok. If fewer than
 avail bytes could be read successfully, return a non-zero error code. */
 typedef unrar_err_t (*unrar_read_func)( void* user_data,
-		void* out, int* count, unrar_pos_t pos );
+		void* out, long* count, unrar_pos_t pos );
 
 /** Same as unrar_open(), except data is read using supplied function rather
 than from file. */
@@ -94,8 +98,8 @@ typedef struct unrar_info_t
 	const char*     name;       /**< Name, in Unicode if is_unicode is true */
     const blargg_wchar_t*  name_w;     /**< Name in Unicode, "" if unavailable */
 	unrar_bool      is_unicode; /**< True if name is Unicode (UTF-8) */
-	unsigned int    dos_date;   /**< Date in DOS-style format, 0 if unavailable */
+	uint            dos_date;   /**< Date in DOS-style format, 0 if unavailable */
-	unsigned int    crc;        /**< Checksum; algorithm depends on archive */
+	uint            crc;        /**< Checksum; algorithm depends on archive */
 	unrar_bool      is_crc32;   /**< True if crc is CRC-32 */
 } unrar_info_t;
 
@@ -127,7 +131,7 @@ that passed to unrar_extract_custom(). Callback must do the following: Write
 count bytes from *in to wherever extracted data goes and return unrar_ok. If
 data cannot be written successfully, return a non-zero error code. */
 typedef unrar_err_t (*unrar_write_func)( void* user_data,
-		const void* in, int count );
+		const void* in, uint count );
 
 /**  Extracts current file and writes data using supplied function. Any error
 it returns will be returned by this function, and archive will still be

Frameworks/File_Extractor/File_Extractor/unrar/unrar_misc.cpp

@@ -24,7 +24,7 @@ struct unrar_extract_mem_t
 };
 
 extern "C" {
-	static unrar_err_t extract_write( void* user_data, const void* in, int count )
+	static unrar_err_t extract_write( void* user_data, const void* in, uint count )
 	{
 		unrar_extract_mem_t* p = (unrar_extract_mem_t*) user_data;
 		
@@ -53,13 +53,13 @@ unrar_err_t unrar_extract( unrar_t* p, void* out, unrar_pos_t size )
 }
 
 inline
-static bool is_entire_file( const unrar_t* p, const void* in, int count )
+static bool is_entire_file( const unrar_t* p, const void* in, uint count )
 {
 	return (count == p->Arc.NewLhd.UnpSize && p->Unp && in == p->Unp->window_wrptr());
 }
 	
 extern "C" {
-	static unrar_err_t extract_mem( void* data, void const* in, int count )
+	static unrar_err_t extract_mem( void* data, void const* in, uint count )
 	{
 		unrar_t* p = (unrar_t*) data;
 		
@@ -129,7 +129,7 @@ const char* unrar_err_str( unrar_err_t err )
 	return "problem with RAR";
 }
 
-int ComprDataIO::Read( void* p, int n )
+long ComprDataIO::Read( void* p, long n )
 {
 	unrar_err_t err = user_read( user_read_data, p, &n, Tell_ );
 	if ( err )
@@ -142,7 +142,7 @@ int ComprDataIO::Read( void* p, int n )
 	return n;
 }
 
-void ComprDataIO::UnpWrite( byte* out, uint count )
+void ComprDataIO::UnpWrite( byte* out, long count )
 {
 	if ( !SkipUnpCRC )
 	{
@@ -156,7 +156,7 @@ void ComprDataIO::UnpWrite( byte* out, uint count )
 	}
 }
 
-int ComprDataIO::UnpRead( byte* out, uint count )
+long ComprDataIO::UnpRead( byte* out, long count )
 {
 	if ( count <= 0 )
 		return 0;
@@ -164,7 +164,7 @@ int ComprDataIO::UnpRead( byte* out, uint count )
 	if ( count > (uint) UnpPackedSize )
 		count = UnpPackedSize;
 
-	int result = Read( out, count );
+	long result = Read( out, count );
 	UnpPackedSize -= result;
 	return result;
 }

Frameworks/File_Extractor/File_Extractor/unrar/unrar_open.cpp

@@ -5,7 +5,7 @@
 #include <stdio.h>
 
 extern "C" {
-	static unrar_err_t unrar_read_file( void* user_data, void* out, int* count, unrar_pos_t pos )
+	static unrar_err_t unrar_read_file( void* user_data, void* out, long* count, unrar_pos_t pos )
 	{
 		FILE* file = (FILE*) user_data;