kode54
/
cog
2
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Whoops, last File_Extractor update broke rarvm, reverted that mess and fixed all the warnings with casting

CQTexperiment
Chris Moeller 2013-10-04 16:31:10 -07:00
parent d76c1c2210
commit 145dd84c35
28 changed files with 279 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Frameworks/File_Extractor/File_Extractor/fex/Rar_Extractor.cpp
View File

@ -81,7 +81,7 @@ static inline unrar_err_t handle_err( Rar_Extractor::read_callback_t* h, blargg_
extern "C" extern "C"
{ {
static unrar_err_t my_unrar_read( void* data, void* out, long* count, unrar_pos_t pos ) static unrar_err_t my_unrar_read( void* data, void* out, int* count, unrar_pos_t pos )
{ {
Rar_Extractor::read_callback_t* h = STATIC_CAST(Rar_Extractor::read_callback_t*,data); Rar_Extractor::read_callback_t* h = STATIC_CAST(Rar_Extractor::read_callback_t*,data);
if ( h->pos != pos ) if ( h->pos != pos )

8
Frameworks/File_Extractor/File_Extractor/fex/fex.cpp
View File

@ -295,12 +295,18 @@ BLARGG_EXPORT const char* fex_err_details( fex_err_t err )
//// Wrappers //// Wrappers
BLARGG_EXPORT fex_err_t fex_read( fex_t* fe, void* out, int count ) BLARGG_EXPORT fex_err_t fex_read( fex_t* fe, void* out, long count )
{ {
RETURN_ERR( fe->stat() ); RETURN_ERR( fe->stat() );
return fe->reader().read( out, count ); return fe->reader().read( out, count );
} }
BLARGG_EXPORT fex_err_t fex_skip( fex_t* fe, long count )
{
RETURN_ERR( fe->stat() );
return fe->reader().skip( count );
}
BLARGG_EXPORT void fex_close ( fex_t* fe ) { delete fe; } BLARGG_EXPORT void fex_close ( fex_t* fe ) { delete fe; }
BLARGG_EXPORT fex_type_t fex_type ( const fex_t* fe ) { return fe->type(); } BLARGG_EXPORT fex_type_t fex_type ( const fex_t* fe ) { return fe->type(); }
BLARGG_EXPORT int fex_done ( const fex_t* fe ) { return fe->done(); } BLARGG_EXPORT int fex_done ( const fex_t* fe ) { return fe->done(); }

5
Frameworks/File_Extractor/File_Extractor/fex/fex.h
View File

@ -150,11 +150,14 @@ unsigned int fex_crc32( const fex_t* );
/** Reads n bytes from current file. Reading past end of file results in /** Reads n bytes from current file. Reading past end of file results in
fex_err_file_eof. */ fex_err_file_eof. */
fex_err_t fex_read( fex_t*, void* out, int n ); fex_err_t fex_read( fex_t*, void* out, long n );
/** Number of bytes read from current file */ /** Number of bytes read from current file */
uint64_t fex_tell( const fex_t* ); uint64_t fex_tell( const fex_t* );
/** Skips the specified number of bytes in the current file */
fex_err_t fex_skip( fex_t*, long n );
/** Points *out at current file's data in memory. Pointer is valid until /** Points *out at current file's data in memory. Pointer is valid until
fex_next(), fex_rewind(), fex_seek_arc(), or fex_close() is called. Pointer fex_next(), fex_rewind(), fex_seek_arc(), or fex_close() is called. Pointer
must NOT be freed(); library frees it automatically. If error, sets *out to must NOT be freed(); library frees it automatically. If error, sets *out to

3
Frameworks/File_Extractor/File_Extractor/unrar/archive.cpp
View File

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

2
Frameworks/File_Extractor/File_Extractor/unrar/archive.hpp
View File

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

2
Frameworks/File_Extractor/File_Extractor/unrar/arcread.cpp
View File

@ -216,7 +216,7 @@ unrar_err_t Archive::ReadHeader()
// Rar.Read()s are checked by caller of ReadOldHeader() (see above) // Rar.Read()s are checked by caller of ReadOldHeader() (see above)
#ifndef SFX_MODULE #ifndef SFX_MODULE
long Archive::ReadOldHeader() int Archive::ReadOldHeader()
{ {
Raw.Reset(); Raw.Reset();
if (CurBlockPos<=SFXSize) if (CurBlockPos<=SFXSize)

32
Frameworks/File_Extractor/File_Extractor/unrar/array.hpp
View File

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

2
Frameworks/File_Extractor/File_Extractor/unrar/coder.cpp
View File

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

2
Frameworks/File_Extractor/File_Extractor/unrar/coder.hpp
View File

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

4
Frameworks/File_Extractor/File_Extractor/unrar/extract.cpp
View File

@ -95,10 +95,10 @@ unrar_err_t CmdExtract::ExtractCurrentFile( bool SkipSolid, bool check_compatibi
void CmdExtract::UnstoreFile(Int64 DestUnpSize) void CmdExtract::UnstoreFile(Int64 DestUnpSize)
{ {
Buffer.Alloc(Min(DestUnpSize,0x10000)); Buffer.Alloc((int)Min(DestUnpSize,0x10000));
while (1) while (1)
{ {
uint Code=DataIO.UnpRead(&Buffer[0],Buffer.Size()); unsigned int Code=DataIO.UnpRead(&Buffer[0],Buffer.Size());
if (Code==0 || (int)Code==-1) if (Code==0 || (int)Code==-1)
break; break;
Code=Code<DestUnpSize ? Code:int64to32(DestUnpSize); Code=Code<DestUnpSize ? Code:int64to32(DestUnpSize);

2
Frameworks/File_Extractor/File_Extractor/unrar/getbits.cpp
View File

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

6
Frameworks/File_Extractor/File_Extractor/unrar/getbits.hpp
View File

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

6
Frameworks/File_Extractor/File_Extractor/unrar/model.cpp
View File

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

2
Frameworks/File_Extractor/File_Extractor/unrar/model.hpp
View File

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

12
Frameworks/File_Extractor/File_Extractor/unrar/rar.hpp
View File

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

46
Frameworks/File_Extractor/File_Extractor/unrar/rarvm.cpp
View File

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

10
Frameworks/File_Extractor/File_Extractor/unrar/rarvm.hpp
View File

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

2
Frameworks/File_Extractor/File_Extractor/unrar/rawread.cpp
View File

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

10
Frameworks/File_Extractor/File_Extractor/unrar/rawread.hpp
View File

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

28
Frameworks/File_Extractor/File_Extractor/unrar/suballoc.cpp
View File

@ -19,14 +19,14 @@ void SubAllocator::Clean()
} }
inline void SubAllocator::InsertNode(void* p,long indx) inline void SubAllocator::InsertNode(void* p,int indx)
{ {
((RAR_NODE*) p)->next=FreeList[indx].next; ((RAR_NODE*) p)->next=FreeList[indx].next;
FreeList[indx].next=(RAR_NODE*) p; FreeList[indx].next=(RAR_NODE*) p;
} }
inline void* SubAllocator::RemoveNode(long indx) inline void* SubAllocator::RemoveNode(int indx)
{ {
RAR_NODE* RetVal=FreeList[indx].next; RAR_NODE* RetVal=FreeList[indx].next;
FreeList[indx].next=RetVal->next; FreeList[indx].next=RetVal->next;
@ -34,7 +34,7 @@ inline void* SubAllocator::RemoveNode(long indx)
} }
inline uint SubAllocator::U2B(long NU) inline uint SubAllocator::U2B(int NU)
{ {
return /*8*NU+4*NU*/UNIT_SIZE*NU; return /*8*NU+4*NU*/UNIT_SIZE*NU;
} }
@ -44,13 +44,13 @@ inline uint SubAllocator::U2B(long NU)
calculate RAR_MEM_BLK + Items address. Real RAR_MEM_BLK size must be 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 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,long Items) inline RAR_MEM_BLK* SubAllocator::MBPtr(RAR_MEM_BLK *BasePtr,int Items)
{ {
return((RAR_MEM_BLK*)( ((byte *)(BasePtr))+U2B(Items) )); return((RAR_MEM_BLK*)( ((byte *)(BasePtr))+U2B(Items) ));
} }
inline void SubAllocator::SplitBlock(void* pv,long OldIndx,long NewIndx) inline void SubAllocator::SplitBlock(void* pv,int OldIndx,int NewIndx)
{ {
int i, UDiff=Indx2Units[OldIndx]-Indx2Units[NewIndx]; int i, UDiff=Indx2Units[OldIndx]-Indx2Units[NewIndx];
byte* p=((byte*) pv)+U2B(Indx2Units[NewIndx]); byte* p=((byte*) pv)+U2B(Indx2Units[NewIndx]);
@ -76,7 +76,7 @@ void SubAllocator::StopSubAllocator()
} }
bool SubAllocator::StartSubAllocator(long SASize) bool SubAllocator::StartSubAllocator(int SASize)
{ {
uint t=SASize << 20; uint t=SASize << 20;
if (SubAllocatorSize == t) if (SubAllocatorSize == t)
@ -102,9 +102,9 @@ void SubAllocator::InitSubAllocator()
int i, k; int i, k;
memset(FreeList,0,sizeof(FreeList)); memset(FreeList,0,sizeof(FreeList));
pText=HeapStart; pText=HeapStart;
uint Size2=FIXED_UNIT_SIZE*(SubAllocatorSize/8/FIXED_UNIT_SIZE*7); uint Size2=(uint)(FIXED_UNIT_SIZE*(SubAllocatorSize/8/FIXED_UNIT_SIZE*7));
uint RealSize2=Size2/FIXED_UNIT_SIZE*UNIT_SIZE; uint RealSize2=Size2/FIXED_UNIT_SIZE*UNIT_SIZE;
uint Size1=SubAllocatorSize-Size2; uint Size1=(uint)(SubAllocatorSize-Size2);
uint RealSize1=Size1/FIXED_UNIT_SIZE*UNIT_SIZE+Size1%FIXED_UNIT_SIZE; uint RealSize1=Size1/FIXED_UNIT_SIZE*UNIT_SIZE+Size1%FIXED_UNIT_SIZE;
#ifdef STRICT_ALIGNMENT_REQUIRED #ifdef STRICT_ALIGNMENT_REQUIRED
if (Size1%FIXED_UNIT_SIZE!=0) if (Size1%FIXED_UNIT_SIZE!=0)
@ -163,7 +163,7 @@ inline void SubAllocator::GlueFreeBlocks()
} }
} }
void* SubAllocator::AllocUnitsRare(long indx) void* SubAllocator::AllocUnitsRare(int indx)
{ {
if ( !GlueCount ) if ( !GlueCount )
{ {
@ -172,7 +172,7 @@ void* SubAllocator::AllocUnitsRare(long indx)
if ( FreeList[indx].next ) if ( FreeList[indx].next )
return RemoveNode(indx); return RemoveNode(indx);
} }
long i=indx; int i=indx;
do do
{ {
if (++i == N_INDEXES) if (++i == N_INDEXES)
@ -195,7 +195,7 @@ void* SubAllocator::AllocUnitsRare(long indx)
} }
inline void* SubAllocator::AllocUnits(long NU) inline void* SubAllocator::AllocUnits(int NU)
{ {
int indx=Units2Indx[NU-1]; int indx=Units2Indx[NU-1];
if ( FreeList[indx].next ) if ( FreeList[indx].next )
@ -219,7 +219,7 @@ void* SubAllocator::AllocContext()
} }
void* SubAllocator::ExpandUnits(void* OldPtr,long OldNU) void* SubAllocator::ExpandUnits(void* OldPtr,int OldNU)
{ {
int i0=Units2Indx[OldNU-1], i1=Units2Indx[OldNU-1+1]; int i0=Units2Indx[OldNU-1], i1=Units2Indx[OldNU-1+1];
if (i0 == i1) if (i0 == i1)
@ -234,7 +234,7 @@ void* SubAllocator::ExpandUnits(void* OldPtr,long OldNU)
} }
void* SubAllocator::ShrinkUnits(void* OldPtr,long OldNU,long NewNU) void* SubAllocator::ShrinkUnits(void* OldPtr,int OldNU,int NewNU)
{ {
int i0=Units2Indx[OldNU-1], i1=Units2Indx[NewNU-1]; int i0=Units2Indx[OldNU-1], i1=Units2Indx[NewNU-1];
if (i0 == i1) if (i0 == i1)
@ -254,7 +254,7 @@ void* SubAllocator::ShrinkUnits(void* OldPtr,long OldNU,long NewNU)
} }
void SubAllocator::FreeUnits(void* ptr,long OldNU) void SubAllocator::FreeUnits(void* ptr,int OldNU)
{ {
InsertNode(ptr,Units2Indx[OldNU-1]); InsertNode(ptr,Units2Indx[OldNU-1]);
} }

22
Frameworks/File_Extractor/File_Extractor/unrar/suballoc.hpp
View File

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

74
Frameworks/File_Extractor/File_Extractor/unrar/unpack.cpp
View File

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

126
Frameworks/File_Extractor/File_Extractor/unrar/unpack.hpp
View File

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

76
Frameworks/File_Extractor/File_Extractor/unrar/unpack15.cpp
View File

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

32
Frameworks/File_Extractor/File_Extractor/unrar/unpack20.cpp
View File

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

12
Frameworks/File_Extractor/File_Extractor/unrar/unrar.h
View File

@ -37,10 +37,6 @@ typedef unrar_long_long unrar_pos_t;
/** Boolean, where 0 is false and 1 is true */ /** Boolean, where 0 is false and 1 is true */
typedef int unrar_bool; 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 ********/ /******** Open/close ********/
@ -57,7 +53,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 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. */ avail bytes could be read successfully, return a non-zero error code. */
typedef unrar_err_t (*unrar_read_func)( void* user_data, typedef unrar_err_t (*unrar_read_func)( void* user_data,
void* out, long* count, unrar_pos_t pos ); void* out, int* count, unrar_pos_t pos );
/** Same as unrar_open(), except data is read using supplied function rather /** Same as unrar_open(), except data is read using supplied function rather
than from file. */ than from file. */
@ -98,8 +94,8 @@ typedef struct unrar_info_t
const char* name; /**< Name, in Unicode if is_unicode is true */ const char* name; /**< Name, in Unicode if is_unicode is true */
const blargg_wchar_t* name_w; /**< Name in Unicode, "" if unavailable */ const blargg_wchar_t* name_w; /**< Name in Unicode, "" if unavailable */
unrar_bool is_unicode; /**< True if name is Unicode (UTF-8) */ unrar_bool is_unicode; /**< True if name is Unicode (UTF-8) */
uint dos_date; /**< Date in DOS-style format, 0 if unavailable */ unsigned int dos_date; /**< Date in DOS-style format, 0 if unavailable */
uint crc; /**< Checksum; algorithm depends on archive */ unsigned int crc; /**< Checksum; algorithm depends on archive */
unrar_bool is_crc32; /**< True if crc is CRC-32 */ unrar_bool is_crc32; /**< True if crc is CRC-32 */
} unrar_info_t; } unrar_info_t;
@ -131,7 +127,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 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. */ data cannot be written successfully, return a non-zero error code. */
typedef unrar_err_t (*unrar_write_func)( void* user_data, typedef unrar_err_t (*unrar_write_func)( void* user_data,
const void* in, uint count ); const void* in, int count );
/** Extracts current file and writes data using supplied function. Any error /** Extracts current file and writes data using supplied function. Any error
it returns will be returned by this function, and archive will still be it returns will be returned by this function, and archive will still be

18
Frameworks/File_Extractor/File_Extractor/unrar/unrar_misc.cpp
View File

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

2
Frameworks/File_Extractor/File_Extractor/unrar/unrar_open.cpp
View File

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