void MethodTable::Info::show(STATE, Object* self, int level) {
MethodTable* tbl = as<MethodTable>(self);
size_t size = tbl->bins()->to_native();
if(size == 0) {
class_info(state, self, true);
return;
}
class_info(state, self);
std::cout << ": " << size << std::endl;
indent(++level);
for(size_t i = 0; i < size; i++) {
MethodTableBucket* entry = try_as<MethodTableBucket>(tbl->values()->at(state, i));
while(entry) {
if(Symbol* sym = try_as<Symbol>(entry->name())) {
std::cout << ":" << sym->debug_str(state);
} else if(Fixnum* fix = try_as<Fixnum>(entry->name())) {
std::cout << fix->to_native();
}
entry = try_as<MethodTableBucket>(entry->next());
}
if(i < size - 1) std::cout << ", ";
}
std::cout << std::endl;
close_body(level);
}
void Array::Info::show(STATE, Object* self, int level) {
Array* ary = as<Array>(self);
native_int size = ary->size();
native_int stop = size < 5 ? size : 5;
if(size == 0) {
class_info(state, self, true);
return;
}
class_info(state, self);
std::cout << ": " << size << std::endl;
++level;
for(native_int i = 0; i < stop; i++) {
indent(level);
Object* obj = ary->get(state, i);
if(obj == ary) {
class_info(state, obj, true);
} else {
obj->show(state, level);
}
}
if(ary->size() > stop) ellipsis(level);
close_body(level);
}
void Tuple::Info::show_simple(STATE, Object* self, int level) {
Tuple* tup = as<Tuple>(self);
native_int size = tup->num_fields();
native_int stop = size < 6 ? size : 6;
if(size == 0) {
class_info(state, self, true);
return;
}
class_info(state, self);
std::cout << ": " << size << std::endl;
++level;
for(native_int i = 0; i < stop; i++) {
indent(level);
Object* obj = tup->at(state, i);
if(Tuple* t = try_as<Tuple>(obj)) {
class_info(state, self);
std::cout << ": " << t->num_fields() << ">" << std::endl;
} else {
obj->show_simple(state, level);
}
}
if(tup->num_fields() > stop) ellipsis(level);
close_body(level);
}
void SendSite::Info::show(STATE, Object* self, int level) {
SendSite* ss = as<SendSite>(self);
class_header(state, self);
indent_attribute(++level, "name"); ss->name()->show(state, level);
indent_attribute(level, "sender"); class_info(state, ss->sender(), true);
indent_attribute(level, "selector"); class_info(state, ss->selector(), true);
indent_attribute(level, "hits"); std::cout << ss->hits << std::endl;
indent_attribute(level, "misses"); std::cout << ss->misses << std::endl;
indent_attribute(level, "module"); class_info(state, ss->module(), true);
indent_attribute(level, "method"); class_info(state, ss->method(), true);
indent_attribute(level, "recv_class"); class_info(state, ss->recv_class(), true);
close_body(level);
}
Var Interpreter::update_Callable( Var callable, Var varargs ) {
// -> new Callable[ surdef_list, self_type, parm_type ]
TypeInfo *type = type_info( callable.type_expr() );
if ( isa_Void( type->parameters[ 2 ] ) ) {
// -> no previously defined parms
Expr n_data = concat( callable.expr(), pointer_on( varargs.expr() ) );
Var varargs_type = type_of( varargs );
// -> Callable[ surdef_list, self_type, parm_type ]
Var *parms[ 3 ];
parms[ 0 ] = &type->parameters[ 0 ];
parms[ 1 ] = &type->parameters[ 1 ];
parms[ 2 ] = &varargs_type;
Var res( type_for( class_info( class_Callable ), parms ), n_data );
res.add_ref_from( callable );
res.add_ref( callable.expr().size_in_bits(), varargs );
return res;
}
//
PRINT( type->parameters[ 2 ] );
TODO;
return error_var;
}
Var Interpreter::make_Callable( Vec<Var> lst, Var self ) {
// remove doubles
for( int i = 0; i < lst.size(); ++i )
for( int j = i + 1; j < lst.size(); ++j )
if ( lst[ i ].expr() == lst[ j ].expr() )
lst.remove_unordered( j-- );
//
Expr surdef_list_data = cst( SI32( lst.size() ) );
for( int i = 0; i < lst.size(); ++i )
surdef_list_data = concat( surdef_list_data, pointer_on( lst[ i ].expr() ) );
Var surdef_list( &type_SurdefList, surdef_list_data );
//
Var self_type = type_of( self ); // returns void if self is not defined
// -> Callable[ surdef_list, self_type, parm_type ]
Var *parms[ 3 ];
parms[ 0 ] = &surdef_list;
parms[ 1 ] = &self_type;
parms[ 2 ] = &void_var;
Var *callable_type = type_for( class_info( class_Callable ), parms );
return Var( callable_type, self ? pointer_on( self.expr() ) : cst() ).add_ref( 0, self );
}
int
main (int argc, char *argv[])
{
int opcode;
int err_code;
if (argc < 2)
return 1;
opcode = atoi (argv[1]);
switch (opcode)
{
case EMS_SA_CLASS_INFO:
err_code = class_info (argc, argv, 2);
break;
case EMS_SA_DBMT_USER_LOGIN:
err_code = dbmt_user_login (argc, argv, 2);
break;
default:
err_code = 1;
break;
}
return err_code;
}
void InstanceClass::set_verified() {
ClassInfo::Raw info = class_info();
info().set_is_verified();
#if !ENABLE_ISOLATES
JavaClassObj::Raw mirror = java_mirror();
mirror().set_verified();
#endif
}
void Module::Info::show(STATE, Object* self, int level) {
Module* mod = as<Module>(self);
class_header(state, self);
indent_attribute(++level, "name"); mod->name()->show(state, level);
indent_attribute(level, "superclass"); class_info(state, mod->superclass(), true);
indent_attribute(level, "constants"); mod->constants()->show(state, level);
indent_attribute(level, "method_table"); mod->method_table()->show(state, level);
close_body(level);
}
void LookupTable::Info::show(STATE, Object* self, int level) {
LookupTable* tbl = as<LookupTable>(self);
size_t size = tbl->entries()->to_native();
Array* keys = tbl->all_keys(state);
if(size == 0) {
class_info(state, self, true);
return;
}
class_info(state, self);
std::cout << ": " << size << std::endl;
indent(++level);
for(size_t i = 0; i < size; i++) {
std::cout << ":" << as<Symbol>(keys->get(state, i))->c_str(state);
if(i < size - 1) std::cout << ", ";
}
std::cout << std::endl;
close_body(level);
}
bool InstanceClass::is_verified() {
ClassInfo::Raw info = class_info();
bool result = info().is_verified();
#if !ENABLE_ISOLATES && defined(AZZERT)
// Verify that the flag in ClassInfo is in-sync with the mirror object
JavaClassObj::Raw mirror = java_mirror();
GUARANTEE(mirror().is_verified() == result, "sanity");
#endif
return result;
}
void MethodTable::Info::show(STATE, Object* self, int level) {
MethodTable* tbl = as<MethodTable>(self);
size_t size = tbl->entries()->to_native();
Array* names = tbl->all_names(state);
if(size == 0) {
class_info(state, self, true);
return;
}
class_info(state, self);
std::cout << ": " << size << std::endl;
indent(++level);
for(size_t i = 0; i < size; i++) {
if(Symbol* sym = try_as<Symbol>(names->get(state, i))) {
std::cout << ":" << sym->c_str(state);
} else if(Fixnum* fix = try_as<Fixnum>(names->get(state, i))) {
std::cout << fix->to_native();
}
if(i < size - 1) std::cout << ", ";
}
std::cout << std::endl;
close_body(level);
}
Var *Interpreter::_make_varargs_type( const Vec<Var> &uv_args, const Vec<Var> &nv_args, const Vec<int> &nv_name, int off ) {
// class VarargsItemEnd
if ( off >= uv_args.size() + nv_args.size() )
return &type_VarargsItemEnd;
// class VarargsItemBeg[ data_type, data_name, next_type ]
Var data_type = type_of( off >= uv_args.size() ? nv_args[ off - uv_args.size() ] : uv_args[ off ] );
Var data_name( &type_SI32, cst( off >= uv_args.size() ? nv_name[ off - uv_args.size() ] : -1 ) );
Var *parms[ 3 ];
parms[ 0 ] = &data_type;
parms[ 1 ] = &data_name;
parms[ 2 ] = _make_varargs_type( uv_args, nv_args, nv_name, off + 1 );
return type_for( class_info( class_VarargsItemBeg ), parms );
}
void PackedObject::Info::show_simple(STATE, Object* self, int level) {
class_info(state, self, true);
return;
}
CallableInfo *Interpreter::callable_info( const Expr &callable_ptr ) {
if ( CallableInfo *ci = class_info( callable_ptr, false ) ) return ci;
if ( CallableInfo *ci = def_info( callable_ptr, false ) ) return ci;
return 0;
}
void TypeInfo::show_simple(STATE, Object* self, int level) {
class_info(state, self, true);
}
void TypeInfo::class_header(STATE, const Object* self) {
class_info(state, self);
std::cout << "\n";
}
ClassInfo *Interpreter::class_info( const Var &class_var ) {
return class_info( pointer_on( class_var.expr() ) );
}
void Interpreter::_update_base_type_from_class_expr( Var type, Expr class_expr ) {
Expr type_expr = pointer_on( class_expr ); // no parameters.
type.data->ptr = new RefExpr( type_expr );
type_for( class_info( pointer_on( class_expr ) ) ); ///< fill type_info_map
}
