rarvm.java

java下操作rar文件,创建,压缩/解压缩等等.

			case VM_AND: {
				int result = getValue(cmd.isByteMode(), mem, op1)
						& getValue(cmd.isByteMode(), mem, op2);
				flags = result == 0 ? VMFlags.VM_FZ.getFlag() : result
						& VMFlags.VM_FS.getFlag();
				setValue(cmd.isByteMode(), mem, op1, result);
			}
				break;
			case VM_OR: {
				int result = getValue(cmd.isByteMode(), mem, op1)
						| getValue(cmd.isByteMode(), mem, op2);
				flags = result == 0 ? VMFlags.VM_FZ.getFlag() : result
						& VMFlags.VM_FS.getFlag();
				setValue(cmd.isByteMode(), mem, op1, result);
			}
				break;
			case VM_TEST: {
				int result = getValue(cmd.isByteMode(), mem, op1)
						& getValue(cmd.isByteMode(), mem, op2);
				flags = result == 0 ? VMFlags.VM_FZ.getFlag() : result
						& VMFlags.VM_FS.getFlag();
			}
				break;
			case VM_JS:
				if ((flags & VMFlags.VM_FS.getFlag()) != 0) {
					setIP(getValue(false, mem, op1));
					continue;
				}
				break;
			case VM_JNS:
				if ((flags & VMFlags.VM_FS.getFlag()) == 0) {
					setIP(getValue(false, mem, op1));
					continue;
				}
				break;
			case VM_JB:
				if ((flags & VMFlags.VM_FC.getFlag()) != 0) {
					setIP(getValue(false, mem, op1));
					continue;
				}
				break;
			case VM_JBE:
				if ((flags & (VMFlags.VM_FC.getFlag() | VMFlags.VM_FZ.getFlag())) != 0) {
					setIP(getValue(false, mem, op1));
					continue;
				}
				break;
			case VM_JA:
				if ((flags & (VMFlags.VM_FC.getFlag() | VMFlags.VM_FZ.getFlag())) == 0) {
					setIP(getValue(false, mem, op1));
					continue;
				}
				break;
			case VM_JAE:
				if ((flags & VMFlags.VM_FC.getFlag()) == 0) {
					setIP(getValue(false, mem, op1));
					continue;
				}
				break;
			case VM_PUSH:
				R[7] -= 4;
				setValue(false, mem, R[7] & VM_MEMMASK, getValue(false, mem,
						op1));
				break;
			case VM_POP:
				setValue(false, mem, op1, getValue(false, mem, R[7]
						& VM_MEMMASK));
				R[7] += 4;
				break;
			case VM_CALL:
				R[7] -= 4;
				setValue(false, mem, R[7] & VM_MEMMASK, IP + 1);
				setIP(getValue(false, mem, op1));
				continue;
			case VM_NOT:
				setValue(cmd.isByteMode(), mem, op1, ~getValue(
						cmd.isByteMode(), mem, op1));
				break;
			case VM_SHL: {
				int value1 = getValue(cmd.isByteMode(), mem, op1);
				int value2 = getValue(cmd.isByteMode(), mem, op2);
				int result = value1 << value2;
				flags = (result == 0 ? VMFlags.VM_FZ.getFlag()
						: (result & VMFlags.VM_FS.getFlag()))
						| (((value1 << (value2 - 1)) & 0x80000000) != 0 ? VMFlags.VM_FC
								.getFlag()
								: 0);
				setValue(cmd.isByteMode(), mem, op1, result);
			}
				break;
			case VM_SHR: {
				int value1 = getValue(cmd.isByteMode(), mem, op1);
				int value2 = getValue(cmd.isByteMode(), mem, op2);
				int result = value1 >>> value2;
				flags = (result == 0 ? VMFlags.VM_FZ.getFlag()
						: (result & VMFlags.VM_FS.getFlag()))
						| ((value1 >>> (value2 - 1)) & VMFlags.VM_FC.getFlag());
				setValue(cmd.isByteMode(), mem, op1, result);
			}
				break;
			case VM_SAR: {
				int value1 = getValue(cmd.isByteMode(), mem, op1);
				int value2 = getValue(cmd.isByteMode(), mem, op2);
				int result = ((int) value1) >> value2;
				flags = (result == 0 ? VMFlags.VM_FZ.getFlag()
						: (result & VMFlags.VM_FS.getFlag()))
						| ((value1 >> (value2 - 1)) & VMFlags.VM_FC.getFlag());
				setValue(cmd.isByteMode(), mem, op1, result);
			}
				break;
			case VM_NEG: {
				int result = -getValue(cmd.isByteMode(), mem, op1);
				flags = result == 0 ? VMFlags.VM_FZ.getFlag() : VMFlags.VM_FC
						.getFlag()
						| (result & VMFlags.VM_FS.getFlag());
				setValue(cmd.isByteMode(), mem, op1, result);
			}
				break;

			case VM_NEGB:
				setValue(true, mem, op1, -getValue(true, mem, op1));
				break;
			case VM_NEGD:
				setValue(false, mem, op1, -getValue(false, mem, op1));
				break;
			case VM_PUSHA: {
				for (int i = 0, SP = R[7] - 4; i < regCount; i++, SP -= 4) {
					setValue(false, mem, SP & VM_MEMMASK, R[i]);
				}
				R[7] -= regCount * 4;
			}
				break;
			case VM_POPA: {
				for (int i = 0, SP = R[7]; i < regCount; i++, SP += 4)
					R[7 - i] = getValue(false, mem, SP & VM_MEMMASK);
			}
				break;
			case VM_PUSHF:
				R[7] -= 4;
				setValue(false, mem, R[7] & VM_MEMMASK, flags);
				break;
			case VM_POPF:
				flags = getValue(false, mem, R[7] & VM_MEMMASK);
				R[7] += 4;
				break;
			case VM_MOVZX:
				setValue(false, mem, op1, getValue(true, mem, op2));
				break;
			case VM_MOVSX:
				setValue(false, mem, op1, (byte) getValue(true, mem, op2));
				break;
			case VM_XCHG: {
				int value1 = getValue(cmd.isByteMode(), mem, op1);
				setValue(cmd.isByteMode(), mem, op1, getValue(cmd.isByteMode(),
						mem, op2));
				setValue(cmd.isByteMode(), mem, op2, value1);
			}
				break;
			case VM_MUL: {
				int result = (int) (((long) getValue(cmd.isByteMode(), mem, op1)
						& 0xFFffFFff
						* (long) getValue(cmd.isByteMode(), mem, op2) & 0xFFffFFff) & 0xFFffFFff);
				setValue(cmd.isByteMode(), mem, op1, result);
			}
				break;
			case VM_DIV: {
				int divider = getValue(cmd.isByteMode(), mem, op2);
				if (divider != 0) {
					int result = getValue(cmd.isByteMode(), mem, op1) / divider;
					setValue(cmd.isByteMode(), mem, op1, result);
				}
			}
				break;
			case VM_ADC: {
				int value1 = getValue(cmd.isByteMode(), mem, op1);
				int FC = (flags & VMFlags.VM_FC.getFlag());
				int result = (int) ((long) value1 & 0xFFffFFff
						+ (long) getValue(cmd.isByteMode(), mem, op2)
						& 0xFFffFFff + (long) FC & 0xFFffFFff);
				if (cmd.isByteMode()) {
					result &= 0xff;
				}

				flags = (result < value1 || result == value1 && FC != 0) ? 1
						: 0 | (result == 0 ? VMFlags.VM_FZ.getFlag()
								: (result & VMFlags.VM_FS.getFlag()));
				setValue(cmd.isByteMode(), mem, op1, result);
			}
				break;
			case VM_SBB: {
				int value1 = getValue(cmd.isByteMode(), mem, op1);
				int FC = (flags & VMFlags.VM_FC.getFlag());
				int result = (int) ((long) value1 & 0xFFffFFff
						- (long) getValue(cmd.isByteMode(), mem, op2)
						& 0xFFffFFff - (long) FC & 0xFFffFFff);
				if (cmd.isByteMode()) {
					result &= 0xff;
				}
				flags = (result > value1 || result == value1 && FC != 0) ? 1
						: 0 | (result == 0 ? VMFlags.VM_FZ.getFlag()
								: (result & VMFlags.VM_FS.getFlag()));
				setValue(cmd.isByteMode(), mem, op1, result);
			}
				break;

			case VM_RET:
				if (R[7] >= VM_MEMSIZE) {
					return (true);
				}
				setIP(getValue(false, mem, R[7] & VM_MEMMASK));
				R[7] += 4;
				continue;

			case VM_STANDARD:
				ExecuteStandardFilter(VMStandardFilters.findFilter(cmd.getOp1()
						.getData()));
				break;
			case VM_PRINT:
				break;
			}
			IP++;
			--maxOpCount;
		}
	}

	public void prepare(byte[] code, int codeSize, VMPreparedProgram prg) {
		InitBitInput();
		int cpLength = Math.min(maxSize, codeSize);
		for (int i = 0; i < cpLength; i++) // memcpy(inBuf,Code,Min(CodeSize,BitInput::MAX_SIZE));
		{
			inBuf[i] |= code[i];
		}

		byte xorSum = 0;
		for (int i = 1; i < codeSize; i++) {
			xorSum ^= code[i];
		}

		faddbits(8);

		prg.setCmdCount(0);
		if (xorSum == code[0]) {
			VMStandardFilters filterType = IsStandardFilter(code, codeSize);
			if (filterType != VMStandardFilters.VMSF_NONE) {

				VMPreparedCommand curCmd = new VMPreparedCommand();
				curCmd.setOpCode(VMCommands.VM_STANDARD);
				curCmd.getOp1().setData(filterType.getFilter());
				curCmd.getOp1().setType(VMOpType.VM_OPNONE);
				curCmd.getOp2().setType(VMOpType.VM_OPNONE);
				codeSize = 0;			
				prg.getCmd().add(curCmd);
				prg.setCmdCount(prg.getCmdCount()+1);
				// TODO
				// curCmd->Op1.Data=FilterType;
				// >>>>>> CurCmd->Op1.Addr=&CurCmd->Op1.Data; <<<<<<<<<< not set
				// do i need to ?
				// >>>>>> CurCmd->Op2.Addr=&CurCmd->Op2.Data; <<<<<<<<<< "
				// CurCmd->Op1.Type=CurCmd->Op2.Type=VM_OPNONE;
				// CodeSize=0;
			}
			int dataFlag = fgetbits();
			faddbits(1);

			// Read static data contained in DB operators. This data cannot be
			// changed,
			// it is a part of VM code, not a filter parameter.

			if ((dataFlag & 0x8000) != 0) {
				long dataSize = (long) ((long) ReadData(this) & 0xffFFffFF + 1);
				for (int i = 0; inAddr < codeSize && i < dataSize; i++) {
					prg.getStaticData().add(
							Byte.valueOf((byte) (fgetbits() >> 8)));
					faddbits(8);
				}
			}

			while (inAddr < codeSize) {
				VMPreparedCommand curCmd = new VMPreparedCommand();
				int data = fgetbits();
				if ((data & 0x8000) == 0) {
					curCmd.setOpCode(VMCommands.findVMCommand((data >> 12)));
					faddbits(4);
				} else {
					curCmd.setOpCode(VMCommands
							.findVMCommand((data >> 10) - 24));
					faddbits(6);
				}
				if ((VMCmdFlags.VM_CmdFlags[curCmd.getOpCode().getVMCommand()] & VMCmdFlags.VMCF_BYTEMODE) != 0) {
					curCmd.setByteMode((fgetbits() >> 15) == 1 ? true : false);
					faddbits(1);
				} else {
					curCmd.setByteMode(false);
				}
				curCmd.getOp1().setType(VMOpType.VM_OPNONE);
				curCmd.getOp2().setType(VMOpType.VM_OPNONE);

				int opNum = (VMCmdFlags.VM_CmdFlags[curCmd.getOpCode()
						.getVMCommand()] & VMCmdFlags.VMCF_OPMASK);
				// TODO >>> CurCmd->Op1.Addr=CurCmd->Op2.Addr=NULL; <<<???
				if (opNum > 0) {
					decodeArg(curCmd.getOp1(), curCmd.isByteMode());
					if (opNum == 2)
						decodeArg(curCmd.getOp2(), curCmd.isByteMode());
					else {
						if (curCmd.getOp1().getType() == VMOpType.VM_OPINT
								&& (VMCmdFlags.VM_CmdFlags[curCmd.getOpCode()
										.getVMCommand()] & (VMCmdFlags.VMCF_JUMP | VMCmdFlags.VMCF_PROC)) != 0) {
							int distance = curCmd.getOp1().getData();
							if (distance >= 256)
								distance -= 256;
							else {
								if (distance >= 136) {
									distance -= 264;
								} else {
									if (distance >= 16) {
										distance -= 8;
									} else {
										if (distance >= 8) {
											distance -= 16;
										}
									}
								}
								distance += prg.getCmdCount();
							}
							curCmd.getOp1().setData(distance);
						}
					}
				}
				prg.setCmdCount(prg.getCmdCount() + 1);
				prg.getCmd().add(curCmd);
			}
		}
		VMPreparedCommand curCmd = new VMPreparedCommand();
		curCmd.setOpCode(VMCommands.VM_RET);
		// TODO CurCmd->Op1.Addr=&CurCmd->Op1.Data;
		// CurCmd->Op2.Addr=&CurCmd->Op2.Data;
		curCmd.getOp1().setType(VMOpType.VM_OPNONE);
		curCmd.getOp2().setType(VMOpType.VM_OPNONE);

		// for (int i=0;i<prg.getCmdCount();i++)
		// {
		// VM_PreparedCommand *Cmd=&Prg->Cmd[I];
		// if (Cmd->Op1.Addr==NULL)
		// Cmd->Op1.Addr=&Cmd->Op1.Data;
		// if (Cmd->Op2.Addr==NULL)
		// Cmd->Op2.Addr=&Cmd->Op2.Data;
		// }

		prg.getCmd().add(curCmd);
		prg.setCmdCount(prg.getCmdCount()+1);
		// #ifdef VM_OPTIMIZE
		if (codeSize != 0) {
			optimize(prg);
		}
	}

	private void decodeArg(VMPreparedOperand op, boolean byteMode) {
		int data = fgetbits();
		if ((data & 0x8000) != 0) {
			op.setType(VMOpType.VM_OPREG);
			op.setData((data >> 12) & 7);
			op.setOffset(op.getData());
			faddbits(4);
		} else {
			if ((data & 0xc000) == 0) {
				op.setType(VMOpType.VM_OPINT);
				if (byteMode) {
					op.setData((data >> 6) & 0xff);
					faddbits(10);
				} else {
					faddbits(2);
					op.setData(ReadData(this));
				}
			} else {
				op.setType(VMOpType.VM_OPREGMEM);
				if ((data & 0x2000) == 0) {
					op.setData((data >> 10) & 7);
					op.setOffset(op.getData());
					op.setBase(0);
					faddbits(6);
				} else {
					if ((data & 0x1000) == 0) {
						op.setData((data >> 9) & 7);
						op.setOffset(op.getData());
						faddbits(7);
					} else {
						op.setData(0);
						faddbits(4);
					}
					op.setBase(ReadData(this));
				}
			}
		}

	}

	private void optimize(VMPreparedProgram prg) {
		List<VMPreparedCommand> commands = prg.getCmd();

		for (VMPreparedCommand cmd : commands) {
			switch (cmd.getOpCode()) {
			case VM_MOV:
				cmd.setOpCode(cmd.isByteMode() ? VMCommands.VM_MOVB
						: VMCommands.VM_MOVD);
				continue;
			case VM_CMP: