Пример #1
0
        private bool addVMCode(int firstByte, List<byte> vmCode, int length)
        {
            BitInput Inp = new BitInput();
            Inp.InitBitInput();
            // memcpy(Inp.InBuf,Code,Min(BitInput::MAX_SIZE,CodeSize));
            for (int i = 0; i < Math.Min(BitInput.MAX_SIZE, vmCode.Count); i++)
            {
                Inp.InBuf[i] = vmCode[i];
            }
            rarVM.init();

            int FiltPos;
            if ((firstByte & 0x80) != 0)
            {
                FiltPos = RarVM.ReadData(Inp);
                if (FiltPos == 0)
                {
                    initFilters();
                }
                else
                {
                    FiltPos--;
                }
            }
            else
                FiltPos = lastFilter; // use the same filter as last time

            if (FiltPos > filters.Count || FiltPos > oldFilterLengths.Count)
            {
                return (false);
            }
            lastFilter = FiltPos;
            bool NewFilter = (FiltPos == filters.Count);

            UnpackFilter StackFilter = new UnpackFilter(); // new filter for
            // PrgStack

            UnpackFilter Filter;
            if (NewFilter)
            // new filter code, never used before since VM reset
            {
                // too many different filters, corrupt archive
                if (FiltPos > 1024)
                {
                    return (false);
                }

                // Filters[Filters.Size()-1]=Filter=new UnpackFilter;
                Filter = new UnpackFilter();
                filters.Add(Filter);
                StackFilter.ParentFilter = filters.Count - 1;
                oldFilterLengths.Add(0);
                Filter.ExecCount = 0;
            }
            // filter was used in the past
            else
            {
                Filter = filters[FiltPos];
                StackFilter.ParentFilter = FiltPos;
                Filter.ExecCount = Filter.ExecCount + 1; // ->ExecCount++;
            }

            prgStack.Add(StackFilter);
            StackFilter.ExecCount = Filter.ExecCount; // ->ExecCount;

            int BlockStart = RarVM.ReadData(Inp);
            if ((firstByte & 0x40) != 0)
            {
                BlockStart += 258;
            }
            StackFilter.BlockStart = ((BlockStart + unpPtr) & Compress.MAXWINMASK);
            if ((firstByte & 0x20) != 0)
            {
                StackFilter.BlockLength = RarVM.ReadData(Inp);
            }
            else
            {
                StackFilter.BlockLength = FiltPos < oldFilterLengths.Count ? oldFilterLengths[FiltPos] : 0;
            }
            StackFilter.NextWindow = (wrPtr != unpPtr) && ((wrPtr - unpPtr) & Compress.MAXWINMASK) <= BlockStart;

            // DebugLog("\nNextWindow: UnpPtr=%08x WrPtr=%08x
            // BlockStart=%08x",UnpPtr,WrPtr,BlockStart);

            oldFilterLengths[FiltPos] = StackFilter.BlockLength;

            // memset(StackFilter->Prg.InitR,0,sizeof(StackFilter->Prg.InitR));
            Utility.Fill(StackFilter.Program.InitR, 0);
            StackFilter.Program.InitR[3] = RarVM.VM_GLOBALMEMADDR; // StackFilter->Prg.InitR[3]=VM_GLOBALMEMADDR;
            StackFilter.Program.InitR[4] = StackFilter.BlockLength; // StackFilter->Prg.InitR[4]=StackFilter->BlockLength;
            StackFilter.Program.InitR[5] = StackFilter.ExecCount; // StackFilter->Prg.InitR[5]=StackFilter->ExecCount;

            if ((firstByte & 0x10) != 0)
            // set registers to optional parameters
            // if any
            {
                int InitMask = Utility.URShift(Inp.GetBits(), 9);
                Inp.AddBits(7);
                for (int I = 0; I < 7; I++)
                {
                    if ((InitMask & (1 << I)) != 0)
                    {
                        // StackFilter->Prg.InitR[I]=RarVM::ReadData(Inp);
                        StackFilter.Program.InitR[I] = RarVM.ReadData(Inp);
                    }
                }
            }

            if (NewFilter)
            {
                int VMCodeSize = RarVM.ReadData(Inp);
                if (VMCodeSize >= 0x10000 || VMCodeSize == 0)
                {
                    return (false);
                }
                byte[] VMCode = new byte[VMCodeSize];
                for (int I = 0; I < VMCodeSize; I++)
                {
                    if (Inp.Overflow(3))
                    {
                        return (false);
                    }
                    VMCode[I] = (byte)(Inp.GetBits() >> 8);
                    Inp.AddBits(8);
                }
                // VM.Prepare(&VMCode[0],VMCodeSize,&Filter->Prg);
                rarVM.prepare(VMCode, VMCodeSize, Filter.Program);
            }
            StackFilter.Program.AltCommands = Filter.Program.Commands; // StackFilter->Prg.AltCmd=&Filter->Prg.Cmd[0];
            StackFilter.Program.CommandCount = Filter.Program.CommandCount; // StackFilter->Prg.CmdCount=Filter->Prg.CmdCount;

            int StaticDataSize = Filter.Program.StaticData.Count;
            if (StaticDataSize > 0 && StaticDataSize < RarVM.VM_GLOBALMEMSIZE)
            {
                // read statically defined data contained in DB commands
                // StackFilter->Prg.StaticData.Add(StaticDataSize);
                StackFilter.Program.StaticData = Filter.Program.StaticData;
                // memcpy(&StackFilter->Prg.StaticData[0],&Filter->Prg.StaticData[0],StaticDataSize);
            }

            if (StackFilter.Program.GlobalData.Count < RarVM.VM_FIXEDGLOBALSIZE)
            {
                // StackFilter->Prg.GlobalData.Reset();
                // StackFilter->Prg.GlobalData.Add(VM_FIXEDGLOBALSIZE);
                StackFilter.Program.GlobalData.Clear();
                StackFilter.Program.GlobalData.SetSize(RarVM.VM_FIXEDGLOBALSIZE);
            }

            // byte *GlobalData=&StackFilter->Prg.GlobalData[0];

            List<byte> globalData = StackFilter.Program.GlobalData;
            for (int I = 0; I < 7; I++)
            {
                rarVM.SetLowEndianValue(globalData, I * 4, StackFilter.Program.InitR[I]);
            }

            // VM.SetLowEndianValue((uint
            // *)&GlobalData[0x1c],StackFilter->BlockLength);
            rarVM.SetLowEndianValue(globalData, 0x1c, StackFilter.BlockLength);
            // VM.SetLowEndianValue((uint *)&GlobalData[0x20],0);
            rarVM.SetLowEndianValue(globalData, 0x20, 0);
            rarVM.SetLowEndianValue(globalData, 0x24, 0);
            rarVM.SetLowEndianValue(globalData, 0x28, 0);

            // VM.SetLowEndianValue((uint
            // *)&GlobalData[0x2c],StackFilter->ExecCount);
            rarVM.SetLowEndianValue(globalData, 0x2c, StackFilter.ExecCount);
            // memset(&GlobalData[0x30],0,16);
            for (int i = 0; i < 16; i++)
            {
                globalData[0x30 + i] = 0x0;
            }
            if ((firstByte & 8) != 0)
            // put data block passed as parameter if any
            {
                if (Inp.Overflow(3))
                {
                    return (false);
                }
                int DataSize = RarVM.ReadData(Inp);
                if (DataSize > RarVM.VM_GLOBALMEMSIZE - RarVM.VM_FIXEDGLOBALSIZE)
                {
                    return (false);
                }
                int CurSize = StackFilter.Program.GlobalData.Count;
                if (CurSize < DataSize + RarVM.VM_FIXEDGLOBALSIZE)
                {
                    // StackFilter->Prg.GlobalData.Add(DataSize+VM_FIXEDGLOBALSIZE-CurSize);
                    StackFilter.Program.GlobalData.SetSize(DataSize + RarVM.VM_FIXEDGLOBALSIZE - CurSize);
                }
                int offset = RarVM.VM_FIXEDGLOBALSIZE;
                globalData = StackFilter.Program.GlobalData;
                for (int I = 0; I < DataSize; I++)
                {
                    if (Inp.Overflow(3))
                    {
                        return (false);
                    }
                    globalData[offset + I] = (byte)(Utility.URShift(Inp.GetBits(), 8));
                    Inp.AddBits(8);
                }
            }
            return (true);
        }
Пример #2
0
        internal static int ReadData(BitInput rarVM)
        {
            int data = rarVM.GetBits();
            switch (data & 0xc000)
            {

                case 0:
                    rarVM.AddBits(6);
                    return ((data >> 10) & 0xf);

                case 0x4000:
                    if ((data & 0x3c00) == 0)
                    {
                        data = unchecked((int)0xffffff00) | ((data >> 2) & 0xff);
                        rarVM.AddBits(14);
                    }
                    else
                    {
                        data = (data >> 6) & 0xff;
                        rarVM.AddBits(10);
                    }
                    return (data);

                case 0x8000:
                    rarVM.AddBits(2);
                    data = rarVM.GetBits();
                    rarVM.AddBits(16);
                    return (data);

                default:
                    rarVM.AddBits(2);
                    data = (rarVM.GetBits() << 16);
                    rarVM.AddBits(16);
                    data |= rarVM.GetBits();
                    rarVM.AddBits(16);
                    return (data);

            }
        }
Пример #3
0
 internal static int decodeNumber(/*this*/ BitInput input, Decode dec)
 {
     int bits;
     long bitField = input.GetBits() & 0xfffe;
     //        if (bitField < dec.getDecodeLen()[8]) {
     //			if (bitField < dec.getDecodeLen()[4]) {
     //				if (bitField < dec.getDecodeLen()[2]) {
     //					if (bitField < dec.getDecodeLen()[1]) {
     //						bits = 1;
     //					} else {
     //						bits = 2;
     //					}
     //				} else {
     //					if (bitField < dec.getDecodeLen()[3]) {
     //						bits = 3;
     //					} else {
     //						bits = 4;
     //					}
     //				}
     //			} else {
     //				if (bitField < dec.getDecodeLen()[6]) {
     //					if (bitField < dec.getDecodeLen()[5])
     //						bits = 5;
     //					else
     //						bits = 6;
     //				} else {
     //					if (bitField < dec.getDecodeLen()[7]) {
     //						bits = 7;
     //					} else {
     //						bits = 8;
     //					}
     //				}
     //			}
     //		} else {
     //			if (bitField < dec.getDecodeLen()[12]) {
     //				if (bitField < dec.getDecodeLen()[10])
     //					if (bitField < dec.getDecodeLen()[9])
     //						bits = 9;
     //					else
     //						bits = 10;
     //				else if (bitField < dec.getDecodeLen()[11])
     //					bits = 11;
     //				else
     //					bits = 12;
     //			} else {
     //				if (bitField < dec.getDecodeLen()[14]) {
     //					if (bitField < dec.getDecodeLen()[13]) {
     //						bits = 13;
     //					} else {
     //						bits = 14;
     //					}
     //				} else {
     //					bits = 15;
     //				}
     //			}
     //		}
     //		addbits(bits);
     //		int N = dec.getDecodePos()[bits]
     //				+ (((int) bitField - dec.getDecodeLen()[bits - 1]) >>> (16 - bits));
     //		if (N >= dec.getMaxNum()) {
     //			N = 0;
     //		}
     //		return (dec.getDecodeNum()[N]);
     int[] decodeLen = dec.DecodeLen;
     if (bitField < decodeLen[8])
     {
         if (bitField < decodeLen[4])
         {
             if (bitField < decodeLen[2])
             {
                 if (bitField < decodeLen[1])
                 {
                     bits = 1;
                 }
                 else
                 {
                     bits = 2;
                 }
             }
             else
             {
                 if (bitField < decodeLen[3])
                 {
                     bits = 3;
                 }
                 else
                 {
                     bits = 4;
                 }
             }
         }
         else
         {
             if (bitField < decodeLen[6])
             {
                 if (bitField < decodeLen[5])
                     bits = 5;
                 else
                     bits = 6;
             }
             else
             {
                 if (bitField < decodeLen[7])
                 {
                     bits = 7;
                 }
                 else
                 {
                     bits = 8;
                 }
             }
         }
     }
     else
     {
         if (bitField < decodeLen[12])
         {
             if (bitField < decodeLen[10])
                 if (bitField < decodeLen[9])
                     bits = 9;
                 else
                     bits = 10;
             else if (bitField < decodeLen[11])
                 bits = 11;
             else
                 bits = 12;
         }
         else
         {
             if (bitField < decodeLen[14])
             {
                 if (bitField < decodeLen[13])
                 {
                     bits = 13;
                 }
                 else
                 {
                     bits = 14;
                 }
             }
             else
             {
                 bits = 15;
             }
         }
     }
     input.AddBits(bits);
     int N = dec.DecodePos[bits] + (Utility.URShift(((int) bitField - decodeLen[bits - 1]), (16 - bits)));
     if (N >= dec.MaxNum)
     {
         N = 0;
     }
     return (dec.DecodeNum[N]);
 }
Пример #4
0
 private bool addVMCode(int firstByte, List<byte> vmCode, int length)
 {
     int num;
     int lastFilter;
     UnpackFilter filter2;
     int num5;
     BitInput rarVM = new BitInput();
     rarVM.InitBitInput();
     for (num = 0; num < Math.Min(0x8000, vmCode.Count); num++)
     {
         rarVM.InBuf[num] = vmCode[num];
     }
     this.rarVM.init();
     if ((firstByte & 0x80) != 0)
     {
         lastFilter = RarVM.ReadData(rarVM);
         if (lastFilter == 0)
         {
             this.initFilters();
         }
         else
         {
             lastFilter--;
         }
     }
     else
     {
         lastFilter = this.lastFilter;
     }
     if ((lastFilter > this.filters.Count) || (lastFilter > this.oldFilterLengths.Count))
     {
         return false;
     }
     this.lastFilter = lastFilter;
     bool flag = lastFilter == this.filters.Count;
     UnpackFilter item = new UnpackFilter();
     if (flag)
     {
         if (lastFilter > 0x400)
         {
             return false;
         }
         filter2 = new UnpackFilter();
         this.filters.Add(filter2);
         item.ParentFilter = this.filters.Count - 1;
         this.oldFilterLengths.Add(0);
         filter2.ExecCount = 0;
     }
     else
     {
         filter2 = this.filters[lastFilter];
         item.ParentFilter = lastFilter;
         filter2.ExecCount++;
     }
     this.prgStack.Add(item);
     item.ExecCount = filter2.ExecCount;
     int num3 = RarVM.ReadData(rarVM);
     if ((firstByte & 0x40) != 0)
     {
         num3 += 0x102;
     }
     item.BlockStart = (num3 + base.unpPtr) & Compress.MAXWINMASK;
     if ((firstByte & 0x20) != 0)
     {
         item.BlockLength = RarVM.ReadData(rarVM);
     }
     else
     {
         item.BlockLength = (lastFilter < this.oldFilterLengths.Count) ? this.oldFilterLengths[lastFilter] : 0;
     }
     item.NextWindow = (base.wrPtr != base.unpPtr) && (((base.wrPtr - base.unpPtr) & Compress.MAXWINMASK) <= num3);
     this.oldFilterLengths[lastFilter] = item.BlockLength;
     Utility.Fill<int>(item.Program.InitR, 0);
     item.Program.InitR[3] = 0x3c000;
     item.Program.InitR[4] = item.BlockLength;
     item.Program.InitR[5] = item.ExecCount;
     if ((firstByte & 0x10) != 0)
     {
         int num4 = Utility.URShift(rarVM.GetBits(), 9);
         rarVM.AddBits(7);
         for (num5 = 0; num5 < 7; num5++)
         {
             if ((num4 & (((int) 1) << num5)) != 0)
             {
                 item.Program.InitR[num5] = RarVM.ReadData(rarVM);
             }
         }
     }
     if (flag)
     {
         int codeSize = RarVM.ReadData(rarVM);
         if ((codeSize >= 0x10000) || (codeSize == 0))
         {
             return false;
         }
         byte[] code = new byte[codeSize];
         for (num5 = 0; num5 < codeSize; num5++)
         {
             if (rarVM.Overflow(3))
             {
                 return false;
             }
             code[num5] = (byte) (rarVM.GetBits() >> 8);
             rarVM.AddBits(8);
         }
         this.rarVM.prepare(code, codeSize, filter2.Program);
     }
     item.Program.AltCommands = filter2.Program.Commands;
     item.Program.CommandCount = filter2.Program.CommandCount;
     int count = filter2.Program.StaticData.Count;
     if ((count > 0) && (count < 0x2000))
     {
         item.Program.StaticData = filter2.Program.StaticData;
     }
     if (item.Program.GlobalData.Count < 0x40)
     {
         item.Program.GlobalData.Clear();
         Utility.SetSize(item.Program.GlobalData, 0x40);
     }
     List<byte> globalData = item.Program.GlobalData;
     for (num5 = 0; num5 < 7; num5++)
     {
         this.rarVM.SetLowEndianValue(globalData, num5 * 4, item.Program.InitR[num5]);
     }
     this.rarVM.SetLowEndianValue(globalData, 0x1c, item.BlockLength);
     this.rarVM.SetLowEndianValue(globalData, 0x20, 0);
     this.rarVM.SetLowEndianValue(globalData, 0x24, 0);
     this.rarVM.SetLowEndianValue(globalData, 40, 0);
     this.rarVM.SetLowEndianValue(globalData, 0x2c, item.ExecCount);
     for (num = 0; num < 0x10; num++)
     {
         globalData[0x30 + num] = 0;
     }
     if ((firstByte & 8) != 0)
     {
         if (rarVM.Overflow(3))
         {
             return false;
         }
         int num8 = RarVM.ReadData(rarVM);
         if (num8 > 0x1fc0)
         {
             return false;
         }
         int num9 = item.Program.GlobalData.Count;
         if (num9 < (num8 + 0x40))
         {
             Utility.SetSize(item.Program.GlobalData, (num8 + 0x40) - num9);
         }
         int num10 = 0x40;
         globalData = item.Program.GlobalData;
         for (num5 = 0; num5 < num8; num5++)
         {
             if (rarVM.Overflow(3))
             {
                 return false;
             }
             globalData[num10 + num5] = (byte) Utility.URShift(rarVM.GetBits(), 8);
             rarVM.AddBits(8);
         }
     }
     return true;
 }
Пример #5
0
 internal static int decodeNumber(BitInput input, Decode dec)
 {
     int num;
     long num2 = input.GetBits() & 0xfffe;
     int[] decodeLen = dec.DecodeLen;
     if (num2 < decodeLen[8])
     {
         if (num2 < decodeLen[4])
         {
             if (num2 < decodeLen[2])
             {
                 if (num2 < decodeLen[1])
                 {
                     num = 1;
                 }
                 else
                 {
                     num = 2;
                 }
             }
             else if (num2 < decodeLen[3])
             {
                 num = 3;
             }
             else
             {
                 num = 4;
             }
         }
         else if (num2 < decodeLen[6])
         {
             if (num2 < decodeLen[5])
             {
                 num = 5;
             }
             else
             {
                 num = 6;
             }
         }
         else if (num2 < decodeLen[7])
         {
             num = 7;
         }
         else
         {
             num = 8;
         }
     }
     else if (num2 < decodeLen[12])
     {
         if (num2 < decodeLen[10])
         {
             if (num2 < decodeLen[9])
             {
                 num = 9;
             }
             else
             {
                 num = 10;
             }
         }
         else if (num2 < decodeLen[11])
         {
             num = 11;
         }
         else
         {
             num = 12;
         }
     }
     else if (num2 < decodeLen[14])
     {
         if (num2 < decodeLen[13])
         {
             num = 13;
         }
         else
         {
             num = 14;
         }
     }
     else
     {
         num = 15;
     }
     input.AddBits(num);
     int index = dec.DecodePos[num] + Utility.URShift((int) (((int) num2) - decodeLen[num - 1]), (int) (0x10 - num));
     if (index >= dec.MaxNum)
     {
         index = 0;
     }
     return dec.DecodeNum[index];
 }
Пример #6
0
        internal static int ReadData(BitInput rarVM)
        {
            int bits = rarVM.GetBits();
            switch ((bits & 0xc000))
            {
                case 0:
                    rarVM.AddBits(6);
                    return ((bits >> 10) & 15);

                case 0x4000:
                    if ((bits & 0x3c00) == 0)
                    {
                        bits = -256 | ((bits >> 2) & 0xff);
                        rarVM.AddBits(14);
                        return bits;
                    }
                    bits = (bits >> 6) & 0xff;
                    rarVM.AddBits(10);
                    return bits;

                case 0x8000:
                    rarVM.AddBits(2);
                    bits = rarVM.GetBits();
                    rarVM.AddBits(0x10);
                    return bits;
            }
            rarVM.AddBits(2);
            bits = rarVM.GetBits() << 0x10;
            rarVM.AddBits(0x10);
            bits |= rarVM.GetBits();
            rarVM.AddBits(0x10);
            return bits;
        }