std::string expr2javat::convert(
const exprt &src,
unsigned &precedence)
{
if(src.id()=="java-this")
return convert_java_this(src, precedence=15);
if(src.id()=="java_instanceof")
return convert_java_instanceof(src, precedence=15);
else if(src.id()==ID_side_effect &&
(src.get(ID_statement)==ID_java_new ||
src.get(ID_statement)==ID_java_new_array))
return convert_java_new(src, precedence=15);
else if(src.id()==ID_side_effect &&
src.get(ID_statement)==ID_throw)
return convert_function(src, "throw", precedence=16);
else if(src.is_constant() && to_constant_expr(src).get_value()==ID_nullptr)
return "nullptr";
else if(src.id()==ID_unassigned)
return "?";
else if(src.id()=="pod_constructor")
return "pod_constructor";
else if(src.id()==ID_virtual_function)
return convert_function(src, "VIRTUAL_FUNCTION", precedence=16);
else if(src.id()==ID_java_string_literal)
return '"'+id2string(src.get(ID_value))+'"'; // Todo: add escaping as needed
else
return expr2ct::convert(src, precedence);
}
uintptr_t search_jass_vmmain()
{
war3_searcher& s = get_war3_searcher();
uintptr_t ptr = 0;
//=========================================
// (1)
//
// push 493E0h
// push 1
// push 1
// push 0
// mov edx, offset s_Config ; "config"
// mov ecx, esi
// call UnknowFunc <----
//=========================================
ptr = s.search_string("config");
ptr += sizeof uintptr_t;
ptr = next_opcode(ptr, 0xE8, 5);
ptr = convert_function(ptr);
//=========================================
// (2)
//
// UnknowFunc:
// push esi
// mov esi, edx
// call GetVMInstance
// cmp [esp+4+arg_8], 0
// mov ecx, eax
// jz short loc_6F44C170
// cmp dword ptr [ecx+20h], 0
// jz short loc_6F44C170
// call UnknowFunc2 <----
//=========================================
ptr = next_opcode(ptr, 0xE8, 5);
ptr += 5;
ptr = next_opcode(ptr, 0xE8, 5);
ptr = convert_function(ptr);
//=========================================
// (3)
//
// UnknowFunc2:
// mov eax, [ecx+20h]
// push 0
// push 493E0h
// push 0
// push eax
// call JassVMMain <----
// retn
//=========================================
ptr = next_opcode(ptr, 0xE8, 5);
ptr = convert_function(ptr);
return ptr;
}
uintptr_t searchInGameChatWhat()
{
//=========================================
// (1)
//
// mov ecx, "InGameChatWhat"
// call sub_6F3304C0
// ds:flt_6F946378
// mov eax, [esi+98h]
// movzx edx, byte ptr [esi+15h]
// push ecx ; txtTime
// lea ecx, [esp+114h+text]
// fstp [esp+114h+var_114]
// push eax ; ctype
// push ecx ; text
// push edx ; PlayerID
// mov ecx, ebx ; this
// call InGameChatWhat <----
//=========================================
uintptr_t ptr = get_war3_searcher().search_string("InGameChatWhat");
ptr += 0x04;
ptr = next_opcode(ptr, 0xE8, 5);
ptr += 0x05;
ptr = next_opcode(ptr, 0xE8, 5);
return convert_function(ptr);
}
void cpp_typecheckt::typecheck_function_bodies()
{
instantiation_stackt old_instantiation_stack;
old_instantiation_stack.swap(instantiation_stack);
while(!function_bodies.empty())
{
symbolt &function_symbol=*function_bodies.front().function_symbol;
template_map.swap(function_bodies.front().template_map);
instantiation_stack.swap(function_bodies.front().instantiation_stack);
function_bodies.pop_front();
if(function_symbol.name=="c::main")
add_argc_argv(function_symbol);
exprt &body=function_symbol.value;
if(body.id()=="cpp_not_typechecked")
continue;
if(body.is_not_nil() &&
!body.is_zero())
{
convert_function(function_symbol);
}
}
old_instantiation_stack.swap(instantiation_stack);
}
void cpp_typecheckt::do_not_typechecked()
{
bool cont;
do
{
cont = false;
std::vector<symbolt *> to_typecheck_list;
context.Foreach_operand([&to_typecheck_list](symbolt &s) {
if(s.value.id() == "cpp_not_typechecked" && s.value.get_bool("is_used"))
{
assert(s.type.is_code());
to_typecheck_list.push_back(&s);
}
});
for(symbolt *sym : to_typecheck_list)
{
if(sym->base_name == "operator=")
{
cpp_declaratort declarator;
declarator.location() = sym->location;
default_assignop_value(
lookup(sym->type.get("#member_name")), declarator);
sym->value.swap(declarator.value());
convert_function(*sym);
cont = true;
}
else if(sym->value.operands().size() == 1)
{
exprt tmp = sym->value.operands()[0];
sym->value.swap(tmp);
convert_function(*sym);
cont = true;
}
else
assert(0); // Don't know what to do!
}
} while(cont);
context.Foreach_operand([](symbolt &s) {
if(s.value.id() == "cpp_not_typechecked")
s.value.make_nil();
});
}
uintptr_t search_create_string()
{
uintptr_t ptr = get_war3_searcher().search_string("I2S");
ptr = *(uintptr_t*)(ptr + 0x05);
ptr = next_opcode(ptr, 0xE8, 5);
ptr += 0x05;
ptr = next_opcode(ptr, 0xE8, 5);
return convert_function(ptr);
}
void goto_difft::convert_function_group(
json_arrayt &result,
const irep_id_sett &function_group) const
{
for(irep_id_sett::const_iterator it=function_group.begin();
it!=function_group.end(); ++it)
{
convert_function(result.push_back(jsont()).make_object(), *it);
}
}
std::string expr2javat::convert(
const exprt &src,
unsigned &precedence)
{
if(src.id()=="java-this")
return convert_java_this(src, precedence=15);
else if(src.id()==ID_side_effect &&
(src.get(ID_statement)==ID_java_new ||
src.get(ID_statement)==ID_java_new_array))
return convert_java_new(src, precedence=15);
else if(src.id()==ID_side_effect &&
src.get(ID_statement)==ID_throw)
return convert_function(src, "throw", precedence=16);
else if(src.is_constant() && to_constant_expr(src).get_value()==ID_nullptr)
return "nullptr";
else if(src.id()==ID_unassigned)
return "?";
else if(src.id()=="pod_constructor")
return "pod_constructor";
else
return expr2ct::convert(src, precedence);
}
int msgpack_convert_object(zval *return_value, zval *tpl, zval **value)
{
zend_class_entry *ce, **pce;
TSRMLS_FETCH();
switch (Z_TYPE_P(tpl))
{
case IS_STRING:
if (zend_lookup_class(
Z_STRVAL_P(tpl), Z_STRLEN_P(tpl),
&pce TSRMLS_CC) != SUCCESS)
{
MSGPACK_ERROR("[msgpack] (%s) Class '%s' not found",
__FUNCTION__, Z_STRVAL_P(tpl));
return FAILURE;
}
ce = *pce;
break;
case IS_OBJECT:
ce = zend_get_class_entry(tpl TSRMLS_CC);
break;
default:
MSGPACK_ERROR("[msgpack] (%s) object type is unsupported",
__FUNCTION__);
return FAILURE;
}
if (Z_TYPE_PP(value) == IS_OBJECT)
{
zend_class_entry *vce;
vce = zend_get_class_entry(*value TSRMLS_CC);
if (strcmp(ce->name, vce->name) == 0)
{
*return_value = **value;
zval_copy_ctor(return_value);
zval_ptr_dtor(value);
return SUCCESS;
}
}
object_init_ex(return_value, ce);
/* Run the constructor if there is one */
if (ce->constructor
&& (ce->constructor->common.fn_flags & ZEND_ACC_PUBLIC))
{
zval *retval_ptr = NULL;
zval ***params = NULL;
int num_args = 0;
zend_fcall_info fci;
zend_fcall_info_cache fcc;
#if ZEND_MODULE_API_NO >= 20090626
fci.size = sizeof(fci);
fci.function_table = EG(function_table);
fci.function_name = NULL;
fci.symbol_table = NULL;
fci.object_ptr = return_value;
fci.retval_ptr_ptr = &retval_ptr;
fci.param_count = num_args;
fci.params = params;
fci.no_separation = 1;
fcc.initialized = 1;
fcc.function_handler = ce->constructor;
fcc.calling_scope = EG(scope);
fcc.called_scope = Z_OBJCE_P(return_value);
fcc.object_ptr = return_value;
#else
fci.size = sizeof(fci);
fci.function_table = EG(function_table);
fci.function_name = NULL;
fci.symbol_table = NULL;
fci.object_pp = &return_value;
fci.retval_ptr_ptr = &retval_ptr;
fci.param_count = num_args;
fci.params = params;
fci.no_separation = 1;
fcc.initialized = 1;
fcc.function_handler = ce->constructor;
fcc.calling_scope = EG(scope);
fcc.object_pp = &return_value;
#endif
if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE)
{
if (params)
{
efree(params);
}
if (retval_ptr)
{
zval_ptr_dtor(&retval_ptr);
}
MSGPACK_WARNING(
"[msgpack] (%s) Invocation of %s's constructor failed",
__FUNCTION__, ce->name);
return FAILURE;
}
if (retval_ptr)
{
zval_ptr_dtor(&retval_ptr);
}
if (params)
{
efree(params);
}
}
switch (Z_TYPE_PP(value))
{
case IS_ARRAY:
{
char *key;
uint key_len;
int key_type;
ulong key_index;
zval **data;
HashPosition pos;
HashTable *ht, *ret;
HashTable *var = NULL;
int num;
ht = HASH_OF(*value);
ret = HASH_OF(return_value);
num = zend_hash_num_elements(ht);
if (num <= 0)
{
zval_ptr_dtor(value);
break;
}
/* string - php_only mode? */
if (ht->nNumOfElements != ht->nNextFreeElement
|| ht->nNumOfElements != ret->nNumOfElements)
{
HashTable *properties = NULL;
HashPosition prop_pos;
ALLOC_HASHTABLE(var);
zend_hash_init(var, num, NULL, NULL, 0);
zend_hash_internal_pointer_reset_ex(ht, &pos);
for (;; zend_hash_move_forward_ex(ht, &pos))
{
key_type = zend_hash_get_current_key_ex(
ht, &key, &key_len, &key_index, 0, &pos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
break;
}
if (zend_hash_get_current_data_ex(
ht, (void *)&data, &pos) != SUCCESS)
{
continue;
}
if (key_type == HASH_KEY_IS_STRING)
{
zval *val;
MSGPACK_CONVERT_COPY_ZVAL(val, data);
if (msgpack_convert_string_to_properties(
return_value, key, key_len, val, var) != SUCCESS)
{
zval_ptr_dtor(&val);
MSGPACK_WARNING(
"[msgpack] (%s) "
"illegal offset type, skip this decoding",
__FUNCTION__);
}
}
}
/* index */
properties = Z_OBJ_HT_P(return_value)->get_properties(
return_value TSRMLS_CC);
if (HASH_OF(tpl))
{
properties = HASH_OF(tpl);
}
zend_hash_internal_pointer_reset_ex(properties, &prop_pos);
zend_hash_internal_pointer_reset_ex(ht, &pos);
for (;; zend_hash_move_forward_ex(ht, &pos))
{
key_type = zend_hash_get_current_key_ex(
ht, &key, &key_len, &key_index, 0, &pos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
break;
}
if (zend_hash_get_current_data_ex(
ht, (void *)&data, &pos) != SUCCESS)
{
continue;
}
switch (key_type)
{
case HASH_KEY_IS_LONG:
{
zval *val;
MSGPACK_CONVERT_COPY_ZVAL(val, data);
if (msgpack_convert_long_to_properties(
ret, &properties, &prop_pos,
key_index, val, var) != SUCCESS)
{
zval_ptr_dtor(&val);
MSGPACK_WARNING(
"[msgpack] (%s) "
"illegal offset type, skip this decoding",
__FUNCTION__);
}
break;
}
case HASH_KEY_IS_STRING:
break;
default:
MSGPACK_WARNING(
"[msgpack] (%s) key is not string nor array",
__FUNCTION__);
break;
}
}
zend_hash_destroy(var);
FREE_HASHTABLE(var);
}
else
{
HashPosition valpos;
int (*convert_function)(zval *, zval *, zval **) = NULL;
zval **arydata, *aryval;
/* index */
zend_hash_internal_pointer_reset_ex(ret, &pos);
zend_hash_internal_pointer_reset_ex(ht, &valpos);
for (;; zend_hash_move_forward_ex(ret, &pos),
zend_hash_move_forward_ex(ht, &valpos))
{
key_type = zend_hash_get_current_key_ex(
ret, &key, &key_len, &key_index, 0, &pos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
break;
}
if (zend_hash_get_current_data_ex(
ret, (void *)&data, &pos) != SUCCESS)
{
continue;
}
switch (Z_TYPE_PP(data))
{
case IS_ARRAY:
convert_function = msgpack_convert_array;
break;
case IS_OBJECT:
//case IS_STRING: -- may have default values of
// class members, so it's not wise to allow
convert_function = msgpack_convert_object;
break;
default:
break;
}
if (zend_hash_get_current_data_ex(
ht, (void *)&arydata, &valpos) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) can't get data value by index",
__FUNCTION__);
return FAILURE;
}
MSGPACK_CONVERT_COPY_ZVAL(aryval, arydata);
if (convert_function)
{
zval *rv;
ALLOC_INIT_ZVAL(rv);
if (convert_function(rv, *data, &aryval) != SUCCESS)
{
zval_ptr_dtor(&aryval);
MSGPACK_WARNING(
"[msgpack] (%s) "
"convert failure in convert_object",
__FUNCTION__);
return FAILURE;
}
zend_symtable_update(
ret, key, key_len, &rv, sizeof(rv), NULL);
}
else
{
zend_symtable_update(
ret, key, key_len, &aryval, sizeof(aryval), NULL);
}
}
}
zval_ptr_dtor(value);
break;
}
default:
{
HashTable *properties = NULL;
HashPosition prop_pos;
properties = Z_OBJ_HT_P(return_value)->get_properties(
return_value TSRMLS_CC);
zend_hash_internal_pointer_reset_ex(properties, &prop_pos);
if (msgpack_convert_long_to_properties(
HASH_OF(return_value), &properties, &prop_pos,
0, *value, NULL) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) illegal offset type, skip this decoding",
__FUNCTION__);
}
break;
}
}
return SUCCESS;
}
int msgpack_convert_array(zval *return_value, zval *tpl, zval **value)
{
TSRMLS_FETCH();
if (Z_TYPE_P(tpl) == IS_ARRAY)
{
char *key;
uint key_len;
int key_type;
ulong key_index;
zval **data, **arydata;
HashPosition pos, valpos;
HashTable *ht, *htval;
int num;
ht = HASH_OF(tpl);
// TODO: maybe need to release memory?
array_init(return_value);
num = zend_hash_num_elements(ht);
if (num <= 0)
{
MSGPACK_WARNING(
"[msgpack] (%s) template array length is 0",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
/* string */
if (ht->nNumOfElements != ht->nNextFreeElement)
{
htval = HASH_OF(*value);
if (!htval)
{
MSGPACK_WARNING(
"[msgpack] (%s) input data is not array",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
zend_hash_internal_pointer_reset_ex(ht, &pos);
zend_hash_internal_pointer_reset_ex(htval, &valpos);
for (;; zend_hash_move_forward_ex(ht, &pos),
zend_hash_move_forward_ex(htval, &valpos))
{
key_type = zend_hash_get_current_key_ex(
ht, &key, &key_len, &key_index, 0, &pos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
break;
}
if (zend_hash_get_current_data_ex(
ht, (void *)&data, &pos) != SUCCESS)
{
continue;
}
if (key_type == HASH_KEY_IS_STRING)
{
int (*convert_function)(zval *, zval *, zval **) = NULL;
zval **dataval, *val;
switch (Z_TYPE_PP(data))
{
case IS_ARRAY:
convert_function = msgpack_convert_array;
break;
case IS_OBJECT:
// case IS_STRING:
convert_function = msgpack_convert_object;
break;
default:
break;
}
if (zend_hash_get_current_data_ex(
htval, (void *)&dataval, &valpos) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) can't get data",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
MSGPACK_CONVERT_COPY_ZVAL(val, dataval);
if (convert_function)
{
zval *rv;
ALLOC_INIT_ZVAL(rv);
if (convert_function(rv, *data, &val) != SUCCESS)
{
zval_ptr_dtor(&val);
return FAILURE;
}
add_assoc_zval_ex(return_value, key, key_len, rv);
}
else
{
add_assoc_zval_ex(return_value, key, key_len, val);
}
}
}
zval_ptr_dtor(value);
return SUCCESS;
}
else
{
/* index */
int (*convert_function)(zval *, zval *, zval **) = NULL;
if (Z_TYPE_PP(value) != IS_ARRAY)
{
MSGPACK_WARNING(
"[msgpack] (%s) unserialized data must be array.",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
zend_hash_internal_pointer_reset_ex(ht, &pos);
key_type = zend_hash_get_current_key_ex(
ht, &key, &key_len, &key_index, 0, &pos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
MSGPACK_WARNING(
"[msgpack] (%s) first element in template array is empty",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
if (zend_hash_get_current_data_ex(
ht, (void *)&data, &pos) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) invalid template: empty array?",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
switch (Z_TYPE_PP(data))
{
case IS_ARRAY:
convert_function = msgpack_convert_array;
break;
case IS_OBJECT:
case IS_STRING:
convert_function = msgpack_convert_object;
break;
default:
break;
}
htval = HASH_OF(*value);
num = zend_hash_num_elements(htval);
if (num <= 0)
{
MSGPACK_WARNING(
"[msgpack] (%s) array length is 0 in unserialized data",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
zend_hash_internal_pointer_reset_ex(htval, &valpos);
for (;; zend_hash_move_forward_ex(htval, &valpos))
{
key_type = zend_hash_get_current_key_ex(
htval, &key, &key_len, &key_index, 0, &valpos);
if (key_type == HASH_KEY_NON_EXISTANT)
{
break;
}
if (zend_hash_get_current_data_ex(
htval, (void *)&arydata, &valpos) != SUCCESS)
{
MSGPACK_WARNING(
"[msgpack] (%s) can't get next data in indexed array",
__FUNCTION__);
continue;
}
switch (key_type)
{
case HASH_KEY_IS_LONG:
{
zval *aryval, *rv;
ALLOC_INIT_ZVAL(rv);
MSGPACK_CONVERT_COPY_ZVAL(aryval, arydata);
if (convert_function)
{
if (convert_function(rv, *data, &aryval) != SUCCESS)
{
zval_ptr_dtor(&aryval);
MSGPACK_WARNING(
"[msgpack] (%s) "
"convert failure in HASH_KEY_IS_LONG "
"in indexed array",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
add_next_index_zval(return_value, rv);
}
else
{
add_next_index_zval(return_value, aryval);
}
break;
}
case HASH_KEY_IS_STRING:
MSGPACK_WARNING(
"[msgpack] (%s) key is string",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
default:
MSGPACK_WARNING(
"[msgpack] (%s) key is not string nor array",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
}
zval_ptr_dtor(value);
return SUCCESS;
}
}
else
{
// shouldn't reach
MSGPACK_WARNING(
"[msgpack] (%s) template is not array",
__FUNCTION__);
zval_ptr_dtor(value);
return FAILURE;
}
// shouldn't reach
zval_ptr_dtor(value);
return FAILURE;
}
int msgpack_convert_array(zval *return_value, zval *tpl, zval *value) /* {{{ */ {
zend_string *key;
int key_type;
ulong key_index;
zval *data;
HashTable *ht, *htval;
if (Z_TYPE_P(tpl) != IS_ARRAY) {
MSGPACK_WARNING("[msgpack] (%s) template is not array", __FUNCTION__);
return FAILURE;
}
if (Z_TYPE_P(value) == IS_INDIRECT) {
value = Z_INDIRECT_P(value);
}
ht = HASH_OF(tpl);
array_init(return_value);
if (zend_hash_num_elements(ht) == 0) {
MSGPACK_WARNING("[msgpack] (%s) template array length is 0", __FUNCTION__);
return FAILURE;
}
/* string */
if (ht->nNumOfElements != ht->nNextFreeElement) {
HashPosition valpos;
htval = HASH_OF(value);
if (!htval) {
MSGPACK_WARNING("[msgpack] (%s) input data is not array", __FUNCTION__);
return FAILURE;
}
zend_hash_internal_pointer_reset_ex(htval, &valpos);
ZEND_HASH_FOREACH_KEY_VAL(ht, key_index, key, data) {
if (key) {
zval *dataval;
int (*convert_function)(zval *, zval *, zval *) = NULL;
switch (Z_TYPE_P(data)) {
case IS_ARRAY:
convert_function = msgpack_convert_array;
break;
case IS_OBJECT:
// case IS_STRING:
convert_function = msgpack_convert_object;
break;
default:
break;
}
if ((dataval = zend_hash_get_current_data_ex(htval, &valpos)) == NULL) {
MSGPACK_WARNING("[msgpack] (%s) can't get data", __FUNCTION__);
return FAILURE;
}
if (Z_TYPE_P(dataval) == IS_INDIRECT) {
dataval = Z_INDIRECT_P(dataval);
}
if (convert_function) {
zval rv;
if (convert_function(&rv, data, dataval) != SUCCESS) {
return FAILURE;
}
zend_symtable_update(Z_ARRVAL_P(return_value), key, &rv);
} else {
Z_TRY_ADDREF_P(dataval);
zend_symtable_update(Z_ARRVAL_P(return_value), key, dataval);
}
}
zend_hash_move_forward_ex(htval, &valpos);
} ZEND_HASH_FOREACH_END();
return SUCCESS;
} else {
