open-dsi
/
clamav
mirror of https://github.com/Cisco-Talos/clamav
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ClamAV is an open source (GPLv2) anti-virus toolkit.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
9002 Commits
40 Branches
228 Tags
220 MiB
 
 
 
 
 
 
Tag: Branch: Tree: 631baca8d5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '631baca8d5'
${ noResults }
clamav/libclamunrar/unrarvm.c

1177 lines
37 KiB
Raw Blame History

/*
* Extract RAR archives
*
* Copyright (C) 2005-2006 trog@uncon.org
* Patches added by Sourcefire, Inc. Copyright (C) 2007-2013
*
* This code is based on the work of Alexander L. Roshal (C)
*
* The unRAR sources may be used in any software to handle RAR
* archives without limitations free of charge, but cannot be used
* to re-create the RAR compression algorithm, which is proprietary.
* Distribution of modified unRAR sources in separate form or as a
* part of other software is permitted, provided that it is clearly
* stated in the documentation and source comments that the code may
* not be used to develop a RAR (WinRAR) compatible archiver.
*/
#if HAVE_CONFIG_H
#include "clamav-config.h"
#endif
#include <stdio.h>
#include <string.h>
#include "libclamunrar/unrar.h"
#include "libclamunrar/unrarvm.h"
#include "libclamunrar/unrarcmd.h"
#ifdef RAR_HIGH_DEBUG
#define rar_dbgmsg printf
#else
static void rar_dbgmsg(const char* fmt,...){}
#endif
#define VMCF_OP0 0
#define VMCF_OP1 1
#define VMCF_OP2 2
#define VMCF_OPMASK 3
#define VMCF_BYTEMODE 4
#define VMCF_JUMP 8
#define VMCF_PROC 16
#define VMCF_USEFLAGS 32
#define VMCF_CHFLAGS 64
static uint8_t vm_cmdflags[]=
{
/* VM_MOV */ VMCF_OP2 | VMCF_BYTEMODE ,
/* VM_CMP */ VMCF_OP2 | VMCF_BYTEMODE | VMCF_CHFLAGS ,
/* VM_ADD */ VMCF_OP2 | VMCF_BYTEMODE | VMCF_CHFLAGS ,
/* VM_SUB */ VMCF_OP2 | VMCF_BYTEMODE | VMCF_CHFLAGS ,
/* VM_JZ */ VMCF_OP1 | VMCF_JUMP | VMCF_USEFLAGS ,
/* VM_JNZ */ VMCF_OP1 | VMCF_JUMP | VMCF_USEFLAGS ,
/* VM_INC */ VMCF_OP1 | VMCF_BYTEMODE | VMCF_CHFLAGS ,
/* VM_DEC */ VMCF_OP1 | VMCF_BYTEMODE | VMCF_CHFLAGS ,
/* VM_JMP */ VMCF_OP1 | VMCF_JUMP ,
/* VM_XOR */ VMCF_OP2 | VMCF_BYTEMODE | VMCF_CHFLAGS ,
/* VM_AND */ VMCF_OP2 | VMCF_BYTEMODE | VMCF_CHFLAGS ,
/* VM_OR */ VMCF_OP2 | VMCF_BYTEMODE | VMCF_CHFLAGS ,
/* VM_TEST */ VMCF_OP2 | VMCF_BYTEMODE | VMCF_CHFLAGS ,
/* VM_JS */ VMCF_OP1 | VMCF_JUMP | VMCF_USEFLAGS ,
/* VM_JNS */ VMCF_OP1 | VMCF_JUMP | VMCF_USEFLAGS ,
/* VM_JB */ VMCF_OP1 | VMCF_JUMP | VMCF_USEFLAGS ,
/* VM_JBE */ VMCF_OP1 | VMCF_JUMP | VMCF_USEFLAGS ,
/* VM_JA */ VMCF_OP1 | VMCF_JUMP | VMCF_USEFLAGS ,
/* VM_JAE */ VMCF_OP1 | VMCF_JUMP | VMCF_USEFLAGS ,
/* VM_PUSH */ VMCF_OP1 ,
/* VM_POP */ VMCF_OP1 ,
/* VM_CALL */ VMCF_OP1 | VMCF_PROC ,
/* VM_RET */ VMCF_OP0 | VMCF_PROC ,
/* VM_NOT */ VMCF_OP1 | VMCF_BYTEMODE ,
/* VM_SHL */ VMCF_OP2 | VMCF_BYTEMODE | VMCF_CHFLAGS ,
/* VM_SHR */ VMCF_OP2 | VMCF_BYTEMODE | VMCF_CHFLAGS ,
/* VM_SAR */ VMCF_OP2 | VMCF_BYTEMODE | VMCF_CHFLAGS ,
/* VM_NEG */ VMCF_OP1 | VMCF_BYTEMODE | VMCF_CHFLAGS ,
/* VM_PUSHA */ VMCF_OP0 ,
/* VM_POPA */ VMCF_OP0 ,
/* VM_PUSHF */ VMCF_OP0 | VMCF_USEFLAGS ,
/* VM_POPF */ VMCF_OP0 | VMCF_CHFLAGS ,
/* VM_MOVZX */ VMCF_OP2 ,
/* VM_MOVSX */ VMCF_OP2 ,
/* VM_XCHG */ VMCF_OP2 | VMCF_BYTEMODE ,
/* VM_MUL */ VMCF_OP2 | VMCF_BYTEMODE ,
/* VM_DIV */ VMCF_OP2 | VMCF_BYTEMODE ,
/* VM_ADC */ VMCF_OP2 | VMCF_BYTEMODE | VMCF_USEFLAGS | VMCF_CHFLAGS ,
/* VM_SBB */ VMCF_OP2 | VMCF_BYTEMODE | VMCF_USEFLAGS | VMCF_CHFLAGS ,
/* VM_PRINT */ VMCF_OP0
};
#define UINT32(x) (sizeof(uint32_t)==4 ? (uint32_t)(x):((x)&0xffffffff))
#if WORDS_BIGENDIAN == 0
#define GET_VALUE(byte_mode,addr) ((byte_mode) ? (*(unsigned char *)(addr)) : UINT32((*(unsigned int *)(addr))))
#else
#define GET_VALUE(byte_mode,addr) ((byte_mode) ? (*(unsigned char *)(addr)) : (((unsigned char *)addr)[0] | ((unsigned char *)addr)[1]<<8 | ((unsigned char *)addr)[2]<<16 | ((unsigned char *)addr)[3]<<24))
#endif
void rarvm_set_value(int byte_mode, unsigned int *addr, unsigned int value)
{
if (byte_mode) {
*(unsigned char *)addr=value;
} else {
#if WORDS_BIGENDIAN == 0
*(uint32_t *)addr = value;
#else
((unsigned char *)addr)[0]=(unsigned char)value;
((unsigned char *)addr)[1]=(unsigned char)(value>>8);
((unsigned char *)addr)[2]=(unsigned char)(value>>16);
((unsigned char *)addr)[3]=(unsigned char)(value>>24);
#endif
}
}
#if WORDS_BIGENDIAN == 0
#define SET_VALUE(byte_mode,addr,value) (void)(((byte_mode) ? (*(unsigned char *)(addr)=(value)):(*(uint32_t *)(addr)=((uint32_t)(value)))))
#else
#define SET_VALUE(byte_mode,addr,value) rarvm_set_value(byte_mode, (unsigned int *)addr, value);
#endif
const uint32_t crc_tab[256]={
0x0, 0x77073096, 0xee0e612c, 0x990951ba, 0x76dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
0xedb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x9b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
0x76dc4190, 0x1db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x6b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x7807c9a2, 0xf00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x86d3d2d, 0x91646c97, 0xe6635c01,
0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
0xedb88320, 0x9abfb3b6, 0x3b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x4db2615, 0x73dc1683,
0xe3630b12, 0x94643b84, 0xd6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0xa00ae27, 0x7d079eb1,
0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x26d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x5005713,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0xcb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0xbdbdf21,
0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
};
uint32_t rar_crc(uint32_t start_crc, void *addr, uint32_t size)
{
unsigned char *data;
int i;
data = addr;
#if WORDS_BIGENDIAN == 0
while (size > 0 && ((long)data & 7))
{
start_crc = crc_tab[(unsigned char)(start_crc^data[0])]^(start_crc>>8);
size--;
data++;
}
while (size >= 8)
{
start_crc ^= *(uint32_t *) data;
start_crc = crc_tab[(unsigned char)start_crc] ^ (start_crc>>8);
start_crc = crc_tab[(unsigned char)start_crc] ^ (start_crc>>8);
start_crc = crc_tab[(unsigned char)start_crc] ^ (start_crc>>8);
start_crc = crc_tab[(unsigned char)start_crc] ^ (start_crc>>8);
start_crc ^= *(uint32_t *)(data+4);
start_crc = crc_tab[(unsigned char)start_crc] ^ (start_crc>>8);
start_crc = crc_tab[(unsigned char)start_crc] ^ (start_crc>>8);
start_crc = crc_tab[(unsigned char)start_crc] ^ (start_crc>>8);
start_crc = crc_tab[(unsigned char)start_crc] ^ (start_crc>>8);
data += 8;
size -= 8;
}
#endif
for (i=0 ; i < size ; i++) {
start_crc = crc_tab[(unsigned char)(start_crc^data[i])]^(start_crc >> 8);
}
return start_crc;
}
int rarvm_init(rarvm_data_t *rarvm_data)
{
rarvm_data->mem = (uint8_t *) rar_malloc(RARVM_MEMSIZE+4);
if (!rarvm_data->mem) {
return FALSE;
}
return TRUE;
}
void rarvm_free(rarvm_data_t *rarvm_data)
{
if (rarvm_data && rarvm_data->mem) {
free(rarvm_data->mem);
rarvm_data->mem = NULL;
}
}
void rarvm_addbits(rarvm_input_t *rarvm_input, int bits)
{
bits += rarvm_input->in_bit;
rarvm_input->in_addr += bits >> 3;
rarvm_input->in_bit = bits & 7;
}
unsigned int rarvm_getbits(rarvm_input_t *rarvm_input)
{
unsigned int bit_field;
bit_field = (unsigned int) rarvm_input->in_buf[rarvm_input->in_addr] << 16;
bit_field |= (unsigned int) rarvm_input->in_buf[rarvm_input->in_addr+1] << 8;
bit_field |= (unsigned int) rarvm_input->in_buf[rarvm_input->in_addr+2];
bit_field >>= (8-rarvm_input->in_bit);
return (bit_field & 0xffff);
}
unsigned int rarvm_read_data(rarvm_input_t *rarvm_input)
{
unsigned int data;
data = rarvm_getbits(rarvm_input);
rar_dbgmsg("rarvm_read_data getbits=%u\n", data);
switch (data & 0xc000) {
case 0:
rarvm_addbits(rarvm_input,6);
rar_dbgmsg("rarvm_read_data=%u\n", ((data>>10)&0x0f));
return ((data>>10)&0x0f);
case 0x4000:
if ((data & 0x3c00) == 0) {
data = 0xffffff00 | ((data>>2) & 0xff);
rarvm_addbits(rarvm_input,14);
} else {
data = (data >> 6) &0xff;
rarvm_addbits(rarvm_input,10);
}
rar_dbgmsg("rarvm_read_data=%u\n", data);
return data;
case 0x8000:
rarvm_addbits(rarvm_input,2);
data = rarvm_getbits(rarvm_input);
rarvm_addbits(rarvm_input,16);
rar_dbgmsg("rarvm_read_data=%u\n", data);
return data;
default:
rarvm_addbits(rarvm_input,2);
data = (rarvm_getbits(rarvm_input) << 16);
rarvm_addbits(rarvm_input,16);
data |= rarvm_getbits(rarvm_input);
rarvm_addbits(rarvm_input,16);
rar_dbgmsg("rarvm_read_data=%u\n", data);
return data;
}
}
static rarvm_standard_filters_t is_standard_filter(unsigned char *code, int code_size)
{
uint32_t code_crc;
int i;
struct standard_filter_signature
{
int length;
uint32_t crc;
rarvm_standard_filters_t type;
} std_filt_list[] = {
{53, 0xad576887, VMSF_E8},
{57, 0x3cd7e57e, VMSF_E8E9},
{120, 0x3769893f, VMSF_ITANIUM},
{29, 0x0e06077d, VMSF_DELTA},
{149, 0x1c2c5dc8, VMSF_RGB},
{216, 0xbc85e701, VMSF_AUDIO},
{40, 0x46b9c560, VMSF_UPCASE}
};
code_crc = rar_crc(0xffffffff, code, code_size)^0xffffffff;
rar_dbgmsg("code_crc=%u\n", code_crc);
for (i=0 ; i<sizeof(std_filt_list)/sizeof(std_filt_list[0]) ; i++) {
if (std_filt_list[i].crc == code_crc && std_filt_list[i].length == code_size) {
return std_filt_list[i].type;
}
}
return VMSF_NONE;
}
void rarvm_set_memory(rarvm_data_t *rarvm_data, unsigned int pos, uint8_t *data, unsigned int data_size)
{
if (pos<RARVM_MEMSIZE && data!=rarvm_data->mem+pos) {
memmove(rarvm_data->mem+pos, data, MIN(data_size, RARVM_MEMSIZE-pos));
}
}
static unsigned int *rarvm_get_operand(rarvm_data_t *rarvm_data,
struct rarvm_prepared_operand *cmd_op)
{
if (cmd_op->type == VM_OPREGMEM) {
return ((unsigned int *)&rarvm_data->mem[(*cmd_op->addr+cmd_op->base) & RARVM_MEMMASK]);
} else {
return cmd_op->addr;
}
}
static unsigned int filter_itanium_getbits(unsigned char *data, int bit_pos, int bit_count)
{
int in_addr=bit_pos/8;
int in_bit=bit_pos&7;
unsigned int bit_field=(unsigned int)data[in_addr++];
bit_field|=(unsigned int)data[in_addr++] << 8;
bit_field|=(unsigned int)data[in_addr++] << 16;
bit_field|=(unsigned int)data[in_addr] << 24;
bit_field >>= in_bit;
return(bit_field & (0xffffffff>>(32-bit_count)));
}
static void filter_itanium_setbits(unsigned char *data, unsigned int bit_field, int bit_pos, int bit_count)
{
int i, in_addr=bit_pos/8;
int in_bit=bit_pos&7;
unsigned int and_mask=0xffffffff>>(32-bit_count);
and_mask=~(and_mask<<in_bit);
bit_field<<=in_bit;
for (i=0 ; i<4 ; i++) {
data[in_addr+i]&=and_mask;
data[in_addr+i]|=bit_field;
and_mask=(and_mask>>8)|0xff000000;
bit_field>>=8;
}
}
static void execute_standard_filter(rarvm_data_t *rarvm_data, rarvm_standard_filters_t filter_type)
{
unsigned char *data, cmp_byte2, cur_byte, *src_data, *dest_data;
int i, j, data_size, channels, src_pos, dest_pos, border, width, PosR;
int op_type, cur_channel, byte_count, start_pos, pa, pb, pc;
unsigned int file_offset, cur_pos, predicted;
int32_t offset, addr;
const int file_size=0x1000000;
switch(filter_type) {
case VMSF_E8:
case VMSF_E8E9:
data=rarvm_data->mem;
data_size = rarvm_data->R[4];
file_offset = rarvm_data->R[6];
if (((unsigned int)data_size >= VM_GLOBALMEMADDR) || (data_size < 4)) {
break;
}
cmp_byte2 = filter_type==VMSF_E8E9 ? 0xe9:0xe8;
for (cur_pos = 0 ; cur_pos < data_size-4 ; ) {
cur_byte = *(data++);
cur_pos++;
if (cur_byte==0xe8 || cur_byte==cmp_byte2) {
offset = cur_pos+file_offset;
addr = GET_VALUE(FALSE, data);
if (addr < 0) {
if (addr+offset >=0 ) {
SET_VALUE(FALSE, data, addr+file_size);
}
} else {
if (addr<file_size) {
SET_VALUE(FALSE, data, addr-offset);
}
}
data += 4;
cur_pos += 4;
}
}
break;
case VMSF_ITANIUM:
data=rarvm_data->mem;
data_size = rarvm_data->R[4];
file_offset = rarvm_data->R[6];
if (((unsigned int)data_size >= VM_GLOBALMEMADDR) || (data_size < 21)) {
break;
}
cur_pos = 0;
file_offset>>=4;
while (cur_pos < data_size-21) {
int Byte = (data[0] & 0x1f) - 0x10;
if (Byte >= 0) {
static unsigned char masks[16]={4,4,6,6,0,0,7,7,4,4,0,0,4,4,0,0};
unsigned char cmd_mask = masks[Byte];
if (cmd_mask != 0) {
for (i=0 ; i <= 2 ; i++) {
if (cmd_mask & (1<<i)) {
start_pos = i*41+5;
op_type = filter_itanium_getbits(data,
start_pos+37, 4);
if (op_type == 5) {
offset = filter_itanium_getbits(data,
start_pos+13, 20);
filter_itanium_setbits(data,
(offset-file_offset)
&0xfffff,start_pos+13,20);
}
}
}
}
}
data += 16;
cur_pos += 16;
file_offset++;
}
break;
case VMSF_DELTA:
data_size = rarvm_data->R[4];
channels = rarvm_data->R[0];
src_pos = 0;
border = data_size*2;
SET_VALUE(FALSE, &rarvm_data->mem[VM_GLOBALMEMADDR+0x20], data_size);
if ((unsigned int)data_size >= VM_GLOBALMEMADDR/2) {
break;
}
for (cur_channel=0 ; cur_channel < channels ; cur_channel++) {
unsigned char prev_byte = 0;
for (dest_pos=data_size+cur_channel ; dest_pos<border ; dest_pos+=channels) {
rarvm_data->mem[dest_pos] = (prev_byte -= rarvm_data->mem[src_pos++]);
}
}
break;
case VMSF_RGB: {
const int channels=3;
data_size = rarvm_data->R[4];
width = rarvm_data->R[0] - 3;
PosR = rarvm_data->R[1];
src_data = rarvm_data->mem;
dest_data = src_data + data_size;
SET_VALUE(FALSE, &rarvm_data->mem[VM_GLOBALMEMADDR+0x20], data_size);
if ((unsigned int)data_size >= VM_GLOBALMEMADDR/2) {
break;
}
for (cur_channel=0 ; cur_channel < channels; cur_channel++) {
unsigned int prev_byte = 0;
for (i=cur_channel ; i<data_size ; i+=channels) {
int upper_pos=i-width;
if (upper_pos >= 3) {
unsigned char *upper_data = dest_data+upper_pos;
unsigned int upper_byte = *upper_data;
unsigned int upper_left_byte = *(upper_data-3);
predicted = prev_byte+upper_byte-upper_left_byte;
pa = abs((int)(predicted-prev_byte));
pb = abs((int)(predicted-upper_byte));
pc = abs((int)(predicted-upper_left_byte));
if (pa <= pb && pa <= pc) {
predicted = prev_byte;
} else {
if (pb <= pc) {
predicted = upper_byte;
} else {
predicted = upper_left_byte;
}
}
} else {
predicted = prev_byte;
}
dest_data[i] = prev_byte = (unsigned char)(predicted-*(src_data++));
}
}
for (i=PosR,border=data_size-2 ; i < border ; i+=3) {
unsigned char g=dest_data[i+1];
dest_data[i] += g;
dest_data[i+2] += g;
}
break;
}
case VMSF_AUDIO: {
int channels=rarvm_data->R[0];
data_size = rarvm_data->R[4];
src_data = rarvm_data->mem;
dest_data = src_data + data_size;
SET_VALUE(FALSE, &rarvm_data->mem[VM_GLOBALMEMADDR+0x20], data_size);
if ((unsigned int)data_size >= VM_GLOBALMEMADDR/2) {
break;
}
for (cur_channel=0 ; cur_channel < channels ; cur_channel++) {
unsigned int prev_byte = 0, prev_delta=0, Dif[7];
int D, D1=0, D2=0, D3=0, K1=0, K2=0, K3=0;
memset(Dif, 0, sizeof(Dif));
for (i=cur_channel, byte_count=0 ; i<data_size ; i+=channels, byte_count++) {
D3=D2;
D2 = prev_delta-D1;
D1 = prev_delta;
predicted = 8*prev_byte+K1*D1+K2*D2+K3*D3;
predicted = (predicted>>3) & 0xff;
cur_byte = *(src_data++);
predicted -= cur_byte;
dest_data[i] = predicted;
prev_delta = (signed char)(predicted-prev_byte);
prev_byte = predicted;
D=((signed char)cur_byte) << 3;
Dif[0] += abs(D);
Dif[1] += abs(D-D1);
Dif[2] += abs(D+D1);
Dif[3] += abs(D-D2);
Dif[4] += abs(D+D2);
Dif[5] += abs(D-D3);
Dif[6] += abs(D+D3);
if ((byte_count & 0x1f) == 0) {
unsigned int min_dif=Dif[0], num_min_dif=0;
Dif[0]=0;
for (j=1 ; j<sizeof(Dif)/sizeof(Dif[0]) ; j++) {
if (Dif[j] < min_dif) {
min_dif = Dif[j];
num_min_dif = j;
}
Dif[j]=0;
}
switch(num_min_dif) {
case 1: if (K1>=-16) K1--; break;
case 2: if (K1 < 16) K1++; break;
case 3: if (K2>=-16) K2--; break;
case 4: if (K2 < 16) K2++; break;
case 5: if (K3>=-16) K3--; break;
case 6: if (K3 < 16) K3++; break;
}
}
}
}
break;
}
case VMSF_UPCASE:
data_size = rarvm_data->R[4];
src_pos = 0;
dest_pos = data_size;
if ((unsigned int)data_size >= VM_GLOBALMEMADDR/2) {
break;
}
while (src_pos < data_size) {
cur_byte = rarvm_data->mem[src_pos++];
if (cur_byte==2 && (cur_byte=rarvm_data->mem[src_pos++]) != 2) {
cur_byte -= 32;
}
rarvm_data->mem[dest_pos++]=cur_byte;
}
SET_VALUE(FALSE, &rarvm_data->mem[VM_GLOBALMEMADDR+0x1c], dest_pos-data_size);
SET_VALUE(FALSE, &rarvm_data->mem[VM_GLOBALMEMADDR+0x20], data_size);
break;
default: /* make gcc happy */
break;
}
}
#define SET_IP(IP) \
if ((IP)>=code_size) \
return TRUE; \
if (--max_ops<=0) \
return FALSE; \
cmd=prepared_code+(IP);
static int rarvm_execute_code(rarvm_data_t *rarvm_data,
struct rarvm_prepared_command *prepared_code, int code_size)
{
int max_ops=25000000, i, SP;
struct rarvm_prepared_command *cmd;
unsigned int value1, value2, result, divider, FC, *op1, *op2;
const int reg_count=sizeof(rarvm_data->R)/sizeof(rarvm_data->R[0]);
rar_dbgmsg("in rarvm_execute_code\n");
cmd = prepared_code;
while (1) {
if (cmd > (prepared_code + code_size)) {
rar_dbgmsg("RAR: code overrun detected\n");
return FALSE;
}
if (cmd < prepared_code) {
rar_dbgmsg("RAR: code underrun detected\n");
return FALSE;
}
op1 = rarvm_get_operand(rarvm_data, &cmd->op1);
op2 = rarvm_get_operand(rarvm_data, &cmd->op2);
rar_dbgmsg("op(%d) op_code: %d, op1=%u, op2=%u\n", 25000000-max_ops,
cmd->op_code, op1, op2);
switch(cmd->op_code) {
case VM_MOV:
SET_VALUE(cmd->byte_mode, op1, GET_VALUE(cmd->byte_mode, op2));
break;
case VM_MOVB:
SET_VALUE(TRUE, op1, GET_VALUE(TRUE, op2));
break;
case VM_MOVD:
SET_VALUE(FALSE, op1, GET_VALUE(FALSE, op2));
break;
case VM_CMP:
value1 = GET_VALUE(cmd->byte_mode, op1);
result = UINT32(value1 - GET_VALUE(cmd->byte_mode, op2));
rarvm_data->Flags = result==0 ? VM_FZ : (result>value1)|(result&VM_FS);
break;
case VM_CMPB:
value1 = GET_VALUE(TRUE, op1);
result = UINT32(value1 - GET_VALUE(TRUE, op2));
rarvm_data->Flags = result==0 ? VM_FZ : (result>value1)|(result&VM_FS);
break;
case VM_CMPD:
value1 = GET_VALUE(FALSE, op1);
result = UINT32(value1 - GET_VALUE(FALSE, op2));
rarvm_data->Flags = result==0 ? VM_FZ : (result>value1)|(result&VM_FS);
break;
case VM_ADD:
value1 = GET_VALUE(cmd->byte_mode, op1);
result = UINT32(value1 + GET_VALUE(cmd->byte_mode, op2));
rarvm_data->Flags = result==0 ? VM_FZ : (result<value1)|(result&VM_FS);
SET_VALUE(cmd->byte_mode, op1, result);
break;
case VM_ADDB:
SET_VALUE(TRUE, op1, GET_VALUE(TRUE, op1)+GET_VALUE(TRUE, op2));
break;
case VM_ADDD:
SET_VALUE(FALSE, op1, GET_VALUE(FALSE, op1)+GET_VALUE(FALSE, op2));
break;
case VM_SUB:
value1 = GET_VALUE(cmd->byte_mode, op1);
result = UINT32(value1 - GET_VALUE(cmd->byte_mode, op2));
rarvm_data->Flags = result==0 ? VM_FZ : (result>value1)|(result&VM_FS);
SET_VALUE(cmd->byte_mode, op1, result);
break;
case VM_SUBB:
SET_VALUE(TRUE, op1, GET_VALUE(TRUE, op1)-GET_VALUE(TRUE, op2));
break;
case VM_SUBD:
SET_VALUE(FALSE, op1, GET_VALUE(FALSE, op1)-GET_VALUE(FALSE, op2));
break;
case VM_JZ:
if ((rarvm_data->Flags & VM_FZ) != 0) {
SET_IP(GET_VALUE(FALSE, op1));
continue;
}
break;
case VM_JNZ:
if ((rarvm_data->Flags & VM_FZ) == 0) {
SET_IP(GET_VALUE(FALSE, op1));
continue;
}
break;
case VM_INC:
result = UINT32(GET_VALUE(cmd->byte_mode, op1)+1);
SET_VALUE(cmd->byte_mode, op1, result);
rarvm_data->Flags = result==0 ? VM_FZ : result&VM_FS;
break;
case VM_INCB:
SET_VALUE(TRUE, op1, GET_VALUE(TRUE, op1)+1);
break;
case VM_INCD:
SET_VALUE(FALSE, op1, GET_VALUE(FALSE, op1)+1);
break;
case VM_DEC:
result = UINT32(GET_VALUE(cmd->byte_mode, op1)-1);
SET_VALUE(cmd->byte_mode, op1, result);
rarvm_data->Flags = result==0 ? VM_FZ : result&VM_FS;
break;
case VM_DECB:
SET_VALUE(TRUE, op1, GET_VALUE(TRUE, op1)-1);
break;
case VM_DECD:
SET_VALUE(FALSE, op1, GET_VALUE(FALSE, op1)-1);
break;
case VM_JMP:
SET_IP(GET_VALUE(FALSE, op1));
continue;
case VM_XOR:
result = UINT32(GET_VALUE(cmd->byte_mode, op1)^GET_VALUE(cmd->byte_mode, op2));
rarvm_data->Flags = result==0 ? VM_FZ : result&VM_FS;
SET_VALUE(cmd->byte_mode, op1, result);
break;
case VM_AND:
result = UINT32(GET_VALUE(cmd->byte_mode, op1)&GET_VALUE(cmd->byte_mode, op2));
rarvm_data->Flags = result==0 ? VM_FZ : result&VM_FS;
SET_VALUE(cmd->byte_mode, op1, result);
break;
case VM_OR:
result = UINT32(GET_VALUE(cmd->byte_mode, op1)|GET_VALUE(cmd->byte_mode, op2));
rarvm_data->Flags = result==0 ? VM_FZ : result&VM_FS;
SET_VALUE(cmd->byte_mode, op1, result);
break;
case VM_TEST:
result = UINT32(GET_VALUE(cmd->byte_mode, op1)&GET_VALUE(cmd->byte_mode, op2));
rarvm_data->Flags = result==0 ? VM_FZ : result&VM_FS;
break;
case VM_JS:
if ((rarvm_data->Flags & VM_FS) != 0) {
SET_IP(GET_VALUE(FALSE, op1));
continue;
}
break;
case VM_JNS:
if ((rarvm_data->Flags & VM_FS) == 0) {
SET_IP(GET_VALUE(FALSE, op1));
continue;
}
break;
case VM_JB:
if ((rarvm_data->Flags & VM_FC) != 0) {
SET_IP(GET_VALUE(FALSE, op1));
continue;
}
break;
case VM_JBE:
if ((rarvm_data->Flags & (VM_FC|VM_FZ)) != 0) {
SET_IP(GET_VALUE(FALSE, op1));
continue;
}
break;
case VM_JA:
if ((rarvm_data->Flags & (VM_FC|VM_FZ)) == 0) {
SET_IP(GET_VALUE(FALSE, op1));
continue;
}
break;
case VM_JAE:
if ((rarvm_data->Flags & VM_FC) == 0) {
SET_IP(GET_VALUE(FALSE, op1));
continue;
}
break;
case VM_PUSH:
rarvm_data->R[7] -= 4;
SET_VALUE(FALSE, (unsigned int *)&rarvm_data->mem[rarvm_data->R[7] &
RARVM_MEMMASK], GET_VALUE(FALSE, op1));
break;
case VM_POP:
SET_VALUE(FALSE, op1, GET_VALUE(FALSE,
(unsigned int *)&rarvm_data->mem[rarvm_data->R[7] & RARVM_MEMMASK]));
rarvm_data->R[7] += 4;
break;
case VM_CALL:
rarvm_data->R[7] -= 4;
SET_VALUE(FALSE, (unsigned int *)&rarvm_data->mem[rarvm_data->R[7] &
RARVM_MEMMASK], cmd-prepared_code+1);
SET_IP(GET_VALUE(FALSE, op1));
continue;
case VM_NOT:
SET_VALUE(cmd->byte_mode, op1, ~GET_VALUE(cmd->byte_mode, op1));
break;
case VM_SHL:
value1 = GET_VALUE(cmd->byte_mode, op1);
value2 = GET_VALUE(cmd->byte_mode, op1);
result = UINT32(value1 << value2);
rarvm_data->Flags = (result==0 ? VM_FZ : (result&VM_FS))|
((value1 << (value2-1))&0x80000000 ? VM_FC:0);
SET_VALUE(cmd->byte_mode, op1, result);
break;
case VM_SHR:
value1 = GET_VALUE(cmd->byte_mode, op1);
value2 = GET_VALUE(cmd->byte_mode, op1);
result = UINT32(value1 >> value2);
rarvm_data->Flags = (result==0 ? VM_FZ : (result&VM_FS))|
((value1 >> (value2-1)) & VM_FC);
SET_VALUE(cmd->byte_mode, op1, result);
break;
case VM_SAR:
value1 = GET_VALUE(cmd->byte_mode, op1);
value2 = GET_VALUE(cmd->byte_mode, op1);
result = UINT32(((int)value1) >> value2);
rarvm_data->Flags = (result==0 ? VM_FZ : (result&VM_FS))|
((value1 >> (value2-1)) & VM_FC);
SET_VALUE(cmd->byte_mode, op1, result);
break;
case VM_NEG:
result = UINT32(-GET_VALUE(cmd->byte_mode, op1));
rarvm_data->Flags = result==0 ? VM_FZ:VM_FC|(result&VM_FS);
SET_VALUE(cmd->byte_mode, op1, result);
break;
case VM_NEGB:
SET_VALUE(TRUE, op1, -GET_VALUE(TRUE, op1));
break;
case VM_NEGD:
SET_VALUE(FALSE, op1, -GET_VALUE(FALSE, op1));
break;
case VM_PUSHA:
for (i=0, SP=rarvm_data->R[7]-4 ; i<reg_count ; i++, SP-=4) {
SET_VALUE(FALSE,
(unsigned int *)&rarvm_data->mem[SP & RARVM_MEMMASK],
rarvm_data->R[i]);
}
rarvm_data->R[7] -= reg_count*4;
break;
case VM_POPA:
for (i=0,SP=rarvm_data->R[7] ; i<reg_count ; i++, SP+=4) {
rarvm_data->R[7-i] = GET_VALUE(FALSE,
(unsigned int *)&rarvm_data->mem[SP & RARVM_MEMMASK]);
}
break;
case VM_PUSHF:
rarvm_data->R[7] -= 4;
SET_VALUE(FALSE,
(unsigned int *)&rarvm_data->mem[rarvm_data->R[7] & RARVM_MEMMASK],
rarvm_data->Flags);
break;
case VM_POPF:
rarvm_data->Flags = GET_VALUE(FALSE,
(unsigned int *)&rarvm_data->mem[rarvm_data->R[7] & RARVM_MEMMASK]);
rarvm_data->R[7] += 4;
break;
case VM_MOVZX:
SET_VALUE(FALSE, op1, GET_VALUE(TRUE, op2));
break;
case VM_MOVSX:
SET_VALUE(FALSE, op1, (signed char)GET_VALUE(TRUE, op2));
break;
case VM_XCHG:
value1 = GET_VALUE(cmd->byte_mode, op1);
SET_VALUE(cmd->byte_mode, op1, GET_VALUE(cmd->byte_mode, op2));
SET_VALUE(cmd->byte_mode, op2, value1);
break;
case VM_MUL:
result = GET_VALUE(cmd->byte_mode, op1) * GET_VALUE(cmd->byte_mode, op2);
SET_VALUE(cmd->byte_mode, op1, result);
break;
case VM_DIV:
divider = GET_VALUE(cmd->byte_mode, op2);
if (divider != 0) {
result = GET_VALUE(cmd->byte_mode, op1) / divider;
SET_VALUE(cmd->byte_mode, op1, result);
}
break;
case VM_ADC:
value1 = GET_VALUE(cmd->byte_mode, op1);
FC = (rarvm_data->Flags & VM_FC);
result = UINT32(value1+GET_VALUE(cmd->byte_mode, op2)+FC);
rarvm_data->Flags = result==0 ? VM_FZ:(result<value1 ||
(result==value1 && FC))|(result&VM_FS);
SET_VALUE(cmd->byte_mode, op1, result);
break;
case VM_SBB:
value1 = GET_VALUE(cmd->byte_mode, op1);
FC = (rarvm_data->Flags & VM_FC);
result = UINT32(value1-GET_VALUE(cmd->byte_mode, op2)-FC);
rarvm_data->Flags = result==0 ? VM_FZ:(result>value1 ||
(result==value1 && FC))|(result&VM_FS);
SET_VALUE(cmd->byte_mode, op1, result);
break;
case VM_RET:
if (rarvm_data->R[7] >= RARVM_MEMSIZE) {
return TRUE;
}
SET_IP(GET_VALUE(FALSE, (unsigned int *)&rarvm_data->mem[rarvm_data->R[7] &
RARVM_MEMMASK]));
rarvm_data->R[7] += 4;
continue;
case VM_STANDARD:
execute_standard_filter(rarvm_data,
(rarvm_standard_filters_t)cmd->op1.data);
break;
case VM_PRINT:
/* DEBUG */
break;
}
cmd++;
--max_ops;
}
}
int rarvm_execute(rarvm_data_t *rarvm_data, struct rarvm_prepared_program *prg)
{
unsigned int global_size, static_size, new_pos, new_size, data_size;
struct rarvm_prepared_command *prepared_code;
rar_dbgmsg("in rarvm_execute\n");
memcpy(rarvm_data->R, prg->init_r, sizeof(prg->init_r));
global_size = MIN(prg->global_size, VM_GLOBALMEMSIZE);
if (global_size) {
memcpy(rarvm_data->mem+VM_GLOBALMEMADDR, &prg->global_data[0], global_size);
}
static_size = MIN(prg->static_size, VM_GLOBALMEMSIZE-global_size);
if (static_size) {
memcpy(rarvm_data->mem+VM_GLOBALMEMADDR+global_size,
&prg->static_data[0], static_size);
}
rarvm_data->R[7] = RARVM_MEMSIZE;
rarvm_data->Flags = 0;
prepared_code=prg->alt_cmd ? prg->alt_cmd : &prg->cmd.array[0];
if(!prepared_code) {
rar_dbgmsg("unrar: rarvm_execute: prepared_code == NULL\n");
return FALSE;
}
if (!rarvm_execute_code(rarvm_data, prepared_code, prg->cmd_count)) {
prepared_code[0].op_code = VM_RET;
}
new_pos = GET_VALUE(FALSE, &rarvm_data->mem[VM_GLOBALMEMADDR+0x20])&RARVM_MEMMASK;
new_size = GET_VALUE(FALSE, &rarvm_data->mem[VM_GLOBALMEMADDR+0x1c])&RARVM_MEMMASK;
if (new_pos+new_size >= RARVM_MEMSIZE) {
new_pos = new_size = 0;
}
prg->filtered_data = rarvm_data->mem + new_pos;
prg->filtered_data_size = new_size;
if (prg->global_data) {
free(prg->global_data);
prg->global_data = NULL;
prg->global_size = 0;
}
data_size = MIN(GET_VALUE(FALSE,
(unsigned int *)&rarvm_data->mem[VM_GLOBALMEMADDR+0x30]),VM_GLOBALMEMSIZE);
if (data_size != 0) {
prg->global_size += data_size+VM_FIXEDGLOBALSIZE;
prg->global_data = rar_realloc2(prg->global_data, prg->global_size);
if(!prg->global_data) {
rar_dbgmsg("unrar: rarvm_execute: rar_realloc2 failed for prg->global_data\n");
return FALSE;
}
memcpy(prg->global_data, &rarvm_data->mem[VM_GLOBALMEMADDR],
data_size+VM_FIXEDGLOBALSIZE);
}
return TRUE;
}
static void rarvm_decode_arg(rarvm_data_t *rarvm_data, rarvm_input_t *rarvm_input,
struct rarvm_prepared_operand *op, int byte_mode)
{
uint16_t data;
data = rarvm_getbits(rarvm_input);
if (data & 0x8000) {
op->type = VM_OPREG;
op->data = (data >> 12) & 7;
op->addr = &rarvm_data->R[op->data];
rarvm_addbits(rarvm_input,4);
} else if ((data & 0xc000) == 0) {
op->type = VM_OPINT;
if (byte_mode) {
op->data = (data>>6) & 0xff;
rarvm_addbits(rarvm_input,10);
} else {
rarvm_addbits(rarvm_input,2);
op->data = rarvm_read_data(rarvm_input);
}
} else {
op->type = VM_OPREGMEM;
if ((data & 0x2000) == 0) {
op->data = (data >> 10) & 7;
op->addr = &rarvm_data->R[op->data];
op->base = 0;
rarvm_addbits(rarvm_input,6);
} else {
if ((data & 0x1000) == 0) {
op->data = (data >> 9) & 7;
op->addr = &rarvm_data->R[op->data];
rarvm_addbits(rarvm_input,7);
} else {
op->data = 0;
rarvm_addbits(rarvm_input,4);
}
op->base = rarvm_read_data(rarvm_input);
}
}
}
static void rarvm_optimize(struct rarvm_prepared_program *prg)
{
struct rarvm_prepared_command *code, *cmd;
int code_size, i, flags_required, j, flags;
code = prg->cmd.array;
code_size = prg->cmd_count;
for (i=0 ; i < code_size ; i++) {
cmd = &code[i];
switch(cmd->op_code) {
case VM_MOV:
cmd->op_code = cmd->byte_mode ? VM_MOVB:VM_MOVD;
continue;
case VM_CMP:
cmd->op_code = cmd->byte_mode ? VM_CMPB:VM_CMPD;
continue;
default: /* make gcc happy */
break;
}
if (cmd->op_code > VM_PRINT) {
continue; /* don't re-optimize, unlikely anyway */
}
if ((vm_cmdflags[cmd->op_code] & VMCF_CHFLAGS) == 0) {
continue;
}
flags_required = FALSE;
for (j=i+1 ; j < code_size ; j++) {
flags = vm_cmdflags[code[j].op_code];
if (flags & (VMCF_JUMP|VMCF_PROC|VMCF_USEFLAGS)) {
flags_required=TRUE;
break;
}
if (flags & VMCF_CHFLAGS) {
break;
}
}
if (flags_required) {
continue;
}
switch(cmd->op_code) {
case VM_ADD:
cmd->op_code = cmd->byte_mode ? VM_ADDB:VM_ADDD;
continue;
case VM_SUB:
cmd->op_code = cmd->byte_mode ? VM_SUBB:VM_SUBD;
continue;
case VM_INC:
cmd->op_code = cmd->byte_mode ? VM_INCB:VM_INCD;
continue;
case VM_DEC:
cmd->op_code = cmd->byte_mode ? VM_DECB:VM_DECD;
continue;
case VM_NEG:
cmd->op_code = cmd->byte_mode ? VM_NEGB:VM_NEGD;
continue;
default: /* make gcc happy */
break;
}
}
}
int rarvm_prepare(rarvm_data_t *rarvm_data, rarvm_input_t *rarvm_input, unsigned char *code,
int code_size, struct rarvm_prepared_program *prg)
{
unsigned char xor_sum;
int i, op_num, distance;
rarvm_standard_filters_t filter_type;
struct rarvm_prepared_command *cur_cmd;
uint32_t data_flag, data;
struct rarvm_prepared_command *cmd;
rar_dbgmsg("in rarvm_prepare code_size=%d\n", code_size);
rarvm_input->in_addr = rarvm_input->in_bit = 0;
memcpy(rarvm_input->in_buf, code, MIN(code_size, 0x8000));
xor_sum = 0;
for (i=1 ; i<code_size; i++) {
rar_dbgmsg("code[%d]=%d\n", i, code[i]);
xor_sum ^= code[i];
}
rar_dbgmsg("xor_sum=%d\n", xor_sum);
rarvm_addbits(rarvm_input,8);
prg->cmd_count = 0;
if (xor_sum == code[0]) {
filter_type = is_standard_filter(code, code_size);
rar_dbgmsg("filter_type=%d\n", filter_type);
if (filter_type != VMSF_NONE) {
rar_cmd_array_add(&prg->cmd, 1);
cur_cmd = &prg->cmd.array[prg->cmd_count++];
cur_cmd->op_code = VM_STANDARD;
cur_cmd->op1.data = filter_type;
cur_cmd->op1.addr = &cur_cmd->op1.data;
cur_cmd->op2.addr = &cur_cmd->op2.data;
cur_cmd->op1.type = cur_cmd->op2.type = VM_OPNONE;
code_size = 0;
}
data_flag = rarvm_getbits(rarvm_input);
rar_dbgmsg("data_flag=%u\n", data_flag);
rarvm_addbits(rarvm_input, 1);
if (data_flag & 0x8000) {
int data_size = rarvm_read_data(rarvm_input)+1;
rar_dbgmsg("data_size=%d\n", data_size);
prg->static_data = rar_malloc(data_size);
if(!prg->static_data) {
rar_dbgmsg("unrar: rarvm_prepare: rar_malloc failed for prg->static_data\n");
return FALSE;
}
for (i=0 ; rarvm_input->in_addr < code_size && i < data_size ; i++) {
prg->static_size++;
prg->static_data = rar_realloc2(prg->static_data, prg->static_size);
if(!prg->static_data) {
rar_dbgmsg("unrar: rarvm_prepare: rar_realloc2 failed for prg->static_data\n");
return FALSE;
}
prg->static_data[i] = rarvm_getbits(rarvm_input) >> 8;
rarvm_addbits(rarvm_input, 8);
}
}
while (rarvm_input->in_addr < code_size) {
rar_cmd_array_add(&prg->cmd, 1);
cur_cmd = &prg->cmd.array[prg->cmd_count];
data = rarvm_getbits(rarvm_input);
rar_dbgmsg("data: %u\n", data);
if ((data & 0x8000) == 0) {
cur_cmd->op_code = (rarvm_commands_t) (data>>12);
rarvm_addbits(rarvm_input, 4);
} else {
cur_cmd->op_code = (rarvm_commands_t) ((data>>10)-24);
rarvm_addbits(rarvm_input, 6);
}
if (vm_cmdflags[cur_cmd->op_code] & VMCF_BYTEMODE) {
cur_cmd->byte_mode = rarvm_getbits(rarvm_input) >> 15;
rarvm_addbits(rarvm_input, 1);
} else {
cur_cmd->byte_mode = 0;
}
cur_cmd->op1.type = cur_cmd->op2.type = VM_OPNONE;
op_num = (vm_cmdflags[cur_cmd->op_code] & VMCF_OPMASK);
rar_dbgmsg("op_num: %d\n", op_num);
cur_cmd->op1.addr = cur_cmd->op2.addr = NULL;
if (op_num > 0) {
rarvm_decode_arg(rarvm_data, rarvm_input,
&cur_cmd->op1, cur_cmd->byte_mode);
if (op_num == 2) {
rarvm_decode_arg(rarvm_data, rarvm_input,
&cur_cmd->op2, cur_cmd->byte_mode);
} else {
if (cur_cmd->op1.type == VM_OPINT &&
(vm_cmdflags[cur_cmd->op_code] &
(VMCF_JUMP|VMCF_PROC))) {
distance = cur_cmd->op1.data;
rar_dbgmsg("distance = %d\n", distance);
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->cmd_count;
}
rar_dbgmsg("distance = %d\n", distance);
cur_cmd->op1.data = distance;
}
}
}
prg->cmd_count++;
}
}
rar_cmd_array_add(&prg->cmd,1);
cur_cmd = &prg->cmd.array[prg->cmd_count++];
cur_cmd->op_code = VM_RET;
cur_cmd->op1.addr = &cur_cmd->op1.data;
cur_cmd->op2.addr = &cur_cmd->op2.data;
cur_cmd->op1.type = cur_cmd->op2.type = VM_OPNONE;
for (i=0 ; i < prg->cmd_count ; i++) {
cmd = &prg->cmd.array[i];
rar_dbgmsg("op_code[%d]=%d\n", i, cmd->op_code);
if (cmd->op1.addr == NULL) {
cmd->op1.addr = &cmd->op1.data;
}
if (cmd->op2.addr == NULL) {
cmd->op2.addr = &cmd->op2.data;
}
}
if (code_size!=0) {
rarvm_optimize(prg);
}
return TRUE;
}