class.c

Go to the documentation of this file.

 
/***** Feature test switches ************************************************/
/***** System headers *******************************************************/
//@cond
#include "vm_config.h"
#include <stdint.h>
#include <string.h>
#include <assert.h>
//@endcond
 
/***** Local headers ********************************************************/
#include "mrubyc.h"
 
/***** Constant values ******************************************************/
/***** Macros ***************************************************************/
#define IS_CLASS_OR_MODULE(v) \
  (mrbc_type(v) == MRBC_TT_CLASS || mrbc_type(v) == MRBC_TT_MODULE)
 
 
/***** Typedefs *************************************************************/
/***** Function prototypes **************************************************/
/***** Local variables ******************************************************/
/***** Global variables *****************************************************/
mrbc_class * const mrbc_class_tbl[MRBC_TT_MAXVAL+1] = {
  0,                            // MRBC_TT_EMPTY     = 0,
  MRBC_CLASS(NilClass),         // MRBC_TT_NIL       = 1,
  MRBC_CLASS(FalseClass),       // MRBC_TT_FALSE     = 2,
  MRBC_CLASS(TrueClass),        // MRBC_TT_TRUE      = 3,
  MRBC_CLASS(Integer),          // MRBC_TT_INTEGER   = 4,
#if MRBC_USE_FLOAT
  MRBC_CLASS(Float),            // MRBC_TT_FLOAT     = 5,
#else
  0,                            // MRBC_TT_FLOAT     = 5,
#endif
  MRBC_CLASS(Symbol),           // MRBC_TT_SYMBOL    = 6,
  0,                            // MRBC_TT_CLASS     = 7,
  0,                            // MRBC_TT_MODULE    = 8,
  0,                            // MRBC_TT_OBJECT    = 9,
  MRBC_CLASS(Proc),             // MRBC_TT_PROC      = 10,
  MRBC_CLASS(Array),            // MRBC_TT_ARRAY     = 11,
#if MRBC_USE_STRING
  MRBC_CLASS(String),           // MRBC_TT_STRING    = 12,
#else
  0,                            // MRBC_TT_STRING    = 12,
#endif
  MRBC_CLASS(Range),            // MRBC_TT_RANGE     = 13,
  MRBC_CLASS(Hash),             // MRBC_TT_HASH      = 14,
  0,                            // MRBC_TT_EXCEPTION = 15,
};
 
 
/***** Signal catching functions ********************************************/
/***** Local functions ******************************************************/
//================================================================
mrbc_class * mrbc_traverse_class_tree( mrbc_class *cls, mrbc_class *nest_buf[], int *nest_idx )
{
  cls = cls->super;
 
  if( cls == 0 ) {
    if( *nest_idx == 0 ) return 0;      // does not have super class.
    cls = nest_buf[--(*nest_idx)];      // rewind to the saved point.
    cls = cls->super;
  }
 
  // when alias module
  if( cls->flag_alias && cls->super ) {
    // save the branch point to nest_buf.
    if( *nest_idx >= MRBC_TRAVERSE_NEST_LEVEL ) {
      mrbc_printf("Warning: Module nest exceeds upper limit.\n");
    } else {
      nest_buf[(*nest_idx)++] = cls;
    }
  }
 
  return cls;
}
 
 
//================================================================
mrbc_class * mrbc_traverse_class_tree_skip( mrbc_class *nest_buf[], int *nest_idx )
{
  if( *nest_idx == 0 ) return 0;        // does not have super class.
  return nest_buf[--(*nest_idx)];       // rewind to the saved point.
}
 
 
/***** Global functions *****************************************************/
 
//----------------------------------------------------------------
static mrbc_class * sub_define_class_or_module(struct VM *vm, const mrbc_class *outer, const char *name, mrbc_class *super, mrbc_vtype vtype)
{
  mrbc_sym sym_id = mrbc_str_to_symid(name);
  if( sym_id < 0 ) {
    mrbc_raise(vm, MRBC_CLASS(Exception), "Overflow MAX_SYMBOLS_COUNT");
    return NULL;
  }
 
  // already defined?
  const mrbc_value *val = outer ?
    mrbc_get_class_const( outer, sym_id ) : mrbc_get_const(sym_id);
 
  if( val ) {
    if( mrbc_type(*val) != vtype ) {    // is not TT_CLASS or TT_MODULE
      mrbc_raisef(vm, MRBC_CLASS(TypeError), "%s is not a %s", name,
                  vtype == MRBC_TT_CLASS ? "class" : "module");
      return NULL;
    }
    return val->cls;
  }
 
  // create a new class/module.
  mrbc_class *cls = mrbc_raw_alloc_no_free( sizeof(mrbc_class) );
  mrbc_sym sym_id1 = sym_id;
 
  if( outer ) {
    char buf[MRBC_NESTED_SYMBOL_BUF_LEN];
 
    mrbc_make_nested_symbol_s( buf, outer->sym_id, sym_id );
    sym_id1 = mrbc_symbol( mrbc_symbol_new( vm, buf ));
  }
 
  *cls = (mrbc_class){
    .sym_id = sym_id1,
    .flag_module = (vtype == MRBC_TT_MODULE),
    .super = super,
#if defined(MRBC_DEBUG)
    .name = name,
#endif
  };
#if defined(MRBC_DEBUG)
  if( vtype == MRBC_TT_CLASS ) {
    cls->obj_mark_[0] = 'C';
    cls->obj_mark_[1] = 'L';
  } else {
    cls->obj_mark_[0] = 'M';
    cls->obj_mark_[1] = 'O';
  }
#endif
  mrbc_kv_init_handle( vm, &cls->ivar, 0 );
 
  // register to global constant
  if( outer ) {
    mrbc_set_class_const( outer, sym_id, &mrbc_immediate_value(vtype, .cls = cls) );
  } else {
    mrbc_set_const( sym_id, &mrbc_immediate_value(vtype, .cls = cls) );
  }
 
  return cls;
}
 
 
//================================================================
mrbc_class * mrbc_define_class(struct VM *vm, const char *name, mrbc_class *super)
{
  return sub_define_class_or_module( vm, NULL, name,
    (super ? super : MRBC_CLASS(Object)), MRBC_TT_CLASS );
}
 
 
//================================================================
mrbc_class * mrbc_define_class_under(struct VM *vm, const mrbc_class *outer, const char *name, mrbc_class *super)
{
  return sub_define_class_or_module( vm, outer, name,
    (super ? super : MRBC_CLASS(Object)), MRBC_TT_CLASS );
}
 
 
//================================================================
mrbc_class * mrbc_define_module(struct VM *vm, const char *name)
{
  return sub_define_class_or_module( vm, NULL, name, NULL, MRBC_TT_MODULE );
}
 
 
//================================================================
mrbc_class * mrbc_define_module_under(struct VM *vm, const mrbc_class *outer, const char *name)
{
  return sub_define_class_or_module( vm, outer, name, NULL, MRBC_TT_MODULE);
}
 
 
//================================================================
void mrbc_define_method(struct VM *vm, mrbc_class *cls, const char *name, mrbc_func_t cfunc)
{
  if( cls == NULL ) cls = MRBC_CLASS(Object);   // set default to Object.
  if( cls->flag_nomethod ) {
    mrbc_raisef(vm, MRBC_CLASS(NotImplementedError),
                "Adding methods to the %s class is not supported",
                mrbc_symid_to_str(cls->sym_id));
    return;
  }
 
  mrbc_method *method = mrbc_raw_alloc_no_free( sizeof(mrbc_method) );
 
  method->type = 'm';
  method->c_func = 1;
  method->sym_id = mrbc_str_to_symid( name );
  if( method->sym_id < 0 ) {
    mrbc_raise(vm, MRBC_CLASS(Exception), "Overflow MAX_SYMBOLS_COUNT");
  }
  method->func = cfunc;
  method->next = cls->method_link;
  cls->method_link = method;
}
 
 
//================================================================
mrbc_value mrbc_instance_new(struct VM *vm, mrbc_class *cls, int size)
{
  mrbc_instance *instance = mrbc_alloc(vm, sizeof(mrbc_instance) + size);
 
  *instance = (mrbc_instance){
    MRBC_INIT_OBJECT_HEADER_DI(IN)
    .cls = cls,
    .ivar = MRBC_KVH_INITIALIZER(vm),
  };
 
  return mrbc_immediate_value(MRBC_TT_OBJECT, .instance = instance);
}
 
 
//================================================================
void mrbc_instance_delete(mrbc_value *v)
{
  assert( mrbc_type(*v) == MRBC_TT_OBJECT );
 
#if MRBC_INSTANCE_DESTRUCTOR
  mrbc_class *cls = v->instance->cls;
  if( !cls->flag_builtin && cls->destructor ) cls->destructor( v );
#endif
 
  mrbc_kv_delete_data( &v->instance->ivar );
  mrbc_raw_free( v->instance );
}
 
 
//================================================================
int mrbc_instance_setiv(mrbc_value *target, mrbc_sym sym_id, mrbc_value *v)
{
  mrbc_kv_handle *kvh;
 
  assert(mrbc_type(*target) == MRBC_TT_CLASS ||
         mrbc_type(*target) == MRBC_TT_OBJECT);
 
  if( mrbc_type(*target) == MRBC_TT_CLASS ) {
    if( target->cls->flag_builtin ) return E_NOTIMP_ERROR;
    kvh = &target->cls->ivar;
  } else {
    kvh = &target->instance->ivar;
  }
 
  mrbc_incref(v);
  mrbc_kv_set( kvh, sym_id, v );
 
  return 0;
}
 
 
//================================================================
mrbc_value mrbc_instance_getiv(mrbc_value *target, mrbc_sym sym_id)
{
  mrbc_kv_handle *kvh;
 
  assert(mrbc_type(*target) == MRBC_TT_CLASS ||
         mrbc_type(*target) == MRBC_TT_OBJECT);
 
  if( mrbc_type(*target) == MRBC_TT_CLASS ) {
    if( target->cls->flag_builtin ) return mrbc_nil_value();
    kvh = &target->cls->ivar;
  } else {
    kvh = &target->instance->ivar;
  }
 
  mrbc_value *v = mrbc_kv_get( kvh, sym_id );
  if( !v ) return mrbc_nil_value();
 
  mrbc_incref(v);
  return *v;
}
 
 
#if defined(MRBC_ALLOC_VMID)
//================================================================
void mrbc_instance_clear_vm_id(mrbc_value *v)
{
  mrbc_set_vm_id( v->instance, 0 );
  mrbc_kv_clear_vm_id( &v->instance->ivar );
}
#endif
 
 
//================================================================
int mrbc_obj_is_kind_of( const mrbc_value *obj, const mrbc_class *tcls )
{
  mrbc_class *cls = find_class_by_object( obj );
  mrbc_class *nest_buf[MRBC_TRAVERSE_NEST_LEVEL];
  int nest_idx = 0;
 
  while( cls != tcls ) {
    cls = mrbc_traverse_class_tree( cls, nest_buf, &nest_idx );
    if( !cls ) return 0;
    if( cls->flag_alias ) cls = cls->aliased;
  }
 
  return 1;
}
 
 
//================================================================
mrbc_class * mrbc_find_method( mrbc_method *r_method, mrbc_class *cls, mrbc_sym sym_id )
{
  mrbc_class *nest_buf[MRBC_TRAVERSE_NEST_LEVEL];
  int nest_idx = 0;
  int flag_module = cls->flag_module;
  mrbc_class *cls_save = cls;
 
  if( cls->flag_alias ) {
    if( cls->super ) nest_buf[nest_idx++] = cls;
    cls = cls->aliased;
  }
 
  while( 1 ) {
    mrbc_method *method;
 
    assert( !cls->flag_alias );
    if( cls->flag_nomethod ) goto next_class;
    for( method = cls->method_link; method != 0; method = method->next ) {
      if( method->sym_id == sym_id ) {
        *r_method = *method;
        r_method->cls = cls_save;
        return cls_save;
      }
    }
 
    struct RBuiltinClass *c = (struct RBuiltinClass *)cls;
    int right = c->num_builtin_method;
    if( right == 0 ) goto next_class;
    right--;
    int left = 0;
 
    while( left < right ) {
      int mid = (left + right) / 2;
      if( c->method_symbols[mid] < sym_id ) {
        left = mid + 1;
      } else {
        right = mid;
      }
    }
 
    if( c->method_symbols[right] == sym_id ) {
      *r_method = (mrbc_method){
        .type = 'm',
        .c_func = 2,
        .sym_id = sym_id,
        .func = c->method_functions[right],
        .cls = cls_save,
      };
      return cls_save;
    }
 
  next_class:
    cls = mrbc_traverse_class_tree( cls, nest_buf, &nest_idx );
    if( cls == NULL ) {
      if( !flag_module ) break;
      cls = MRBC_CLASS(Object);
      flag_module = 0;
    }
    cls_save = cls;
    if( cls->flag_alias ) {
      cls = cls->aliased;
    }
  }  // loop next.
 
  return NULL;
}
 
 
//================================================================
mrbc_class * mrbc_get_class_by_name( const char *name )
{
  mrbc_sym sym_id = mrbc_search_symid(name);
  if( sym_id < 0 ) return NULL;
 
  mrbc_value *obj = mrbc_get_const(sym_id);
  if( obj == NULL ) return NULL;
  if( !IS_CLASS_OR_MODULE(*obj) ) return NULL;
 
  return obj->cls;
}
 
 
//================================================================
mrbc_value mrbc_send( struct VM *vm, mrbc_value *v, int argc,
        mrbc_value *recv, const char *method_name, int n_params, ... )
{
  mrbc_method method;
  mrbc_class *cls = find_class_by_object(recv);
  mrbc_sym sym_id = mrbc_str_to_symid(method_name);
 
  if( mrbc_find_method( &method, cls, sym_id ) == 0 ) {
    mrbc_raisef(vm, MRBC_CLASS(NoMethodError), "undefined method '%s' for %s",
                method_name, mrbc_symid_to_str(cls->sym_id) );
    goto ERROR;
  }
  if( !method.c_func ) {
    mrbc_raisef(vm, MRBC_CLASS(NotImplementedError),
                "Method needs to be C function. '%s' for %s",
                method_name, mrbc_symid_to_str(cls->sym_id) );
    goto ERROR;
  }
 
  // create call stack.
  mrbc_value *regs = v + argc + 2;
  mrbc_decref( &regs[0] );
  regs[0] = *recv;
  mrbc_incref(recv);
 
  va_list ap;
  va_start(ap, n_params);
  int i;
  for( i = 1; i <= n_params; i++ ) {
    mrbc_decref( &regs[i] );
    regs[i] = *va_arg(ap, mrbc_value *);
  }
  mrbc_decref( &regs[i] );
  mrbc_set_nil( &regs[i] );
  va_end(ap);
 
  // call method.
  vm->callee_sym_id = sym_id;
  method.func(vm, regs, n_params);
  mrbc_value ret = regs[0];
 
  for(; i >= 0; i-- ) {
    mrbc_set_tt(&regs[i], MRBC_TT_EMPTY);
  }
 
  return ret;
 
 ERROR:
  return mrbc_nil_value();
}
 
 
//================================================================
void c_ineffect(struct VM *vm, mrbc_value v[], int argc)
{
  // nothing to do.
}
 
 
//================================================================
int mrbc_run_mrblib(const void *bytecode)
{
  // instead of mrbc_vm_open()
  mrbc_vm *vm = mrbc_vm_new( MAX_REGS_SIZE );
 
  if( mrbc_load_mrb(vm, bytecode) ) {
    mrbc_print_vm_exception(vm);
    return 2;
  }
 
  int ret;
 
  mrbc_vm_begin(vm);
  do {
    ret = mrbc_vm_run(vm);
  } while( ret == 0 );
  mrbc_vm_end(vm);
  mrbc_vm_close(vm);
 
  return ret;
}
 
#define MRBC_DEFINE_BUILTIN_CLASS_TABLE
#include "_autogen_builtin_class.h"
#undef MRBC_DEFINE_BUILTIN_CLASS_TABLE
 
 
//================================================================
void mrbc_init_class(void)
{
  mrbc_init_class_c();
  mrbc_init_class_mrblib();
}
 
 
//================================================================
void mrbc_init_class_c(void)
{
  mrbc_value vcls;
 
  for( int i = 0; i < sizeof(MRBC_BuiltinClass)/sizeof(struct MRBC_BuiltinClass); i++ ) {
    mrbc_class *cls = MRBC_BuiltinClass[i].cls;
 
    cls->super = MRBC_BuiltinClass[i].super;
    if( !cls->flag_nomethod ) cls->method_link = 0;
    mrbc_set_tt( &vcls, cls->flag_module ? MRBC_TT_MODULE : MRBC_TT_CLASS );
    vcls.cls = cls;
 
    mrbc_set_const( cls->sym_id, &vcls );
  }
 
#if MRBC_USE_MATH
  mrbc_init_module_math();
#endif
}
 
 
//================================================================
void mrbc_init_class_mrblib(void)
{
  extern const uint8_t mrblib_bytecode[];
  mrbc_run_mrblib(mrblib_bytecode);
}