class.h

Go to the documentation of this file.

 
#ifndef MRBC_SRC_CLASS_H_
#define MRBC_SRC_CLASS_H_
 
/***** Feature test switches ************************************************/
/***** System headers *******************************************************/
//@cond
#include "vm_config.h"
#include <stdint.h>
//@endcond
 
/***** Local headers ********************************************************/
#include "value.h"
#include "keyvalue.h"
#include "error.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/***** Constant values ******************************************************/
#define MRBC_TRAVERSE_NEST_LEVEL 3
#if !defined(MRBC_INSTANCE_DESTRUCTOR)
# define MRBC_INSTANCE_DESTRUCTOR 1
#endif
 
 
/***** Macros ***************************************************************/
#define MRBC_CLASS(cls) ((mrbc_class *)(&mrbc_class_##cls))

#define MRBC_INSTANCE_DATA_PTR(v, t) ((t *)((v)->instance->data))
 
 
/***** Typedefs *************************************************************/
//================================================================
typedef struct RClass {
  /* (note)
     Must match the initial layout of RClass, RBuiltinClass,
     and RBuiltinNoMethodClass for safe casting.
  */
#if defined(MRBC_DEBUG)
  uint8_t obj_mark_[2];           
  const char *name;
#endif
 
  mrbc_sym sym_id;                
  unsigned int flag_builtin : 1;  
  unsigned int flag_nomethod : 1; 
  unsigned int flag_module : 1;   
  unsigned int flag_alias : 1;    
  uint8_t num_builtin_method;     
  struct RClass *super;           
 
  // --- Specific members ---
  union {
    struct RMethod *method_link;  
    struct RClass *aliased;       
  };
 
#if MRBC_INSTANCE_DESTRUCTOR
  void (*destructor)(mrbc_value *);     
#endif
  mrbc_kv_handle ivar;                  
 
} mrbc_class;
 
//@cond
typedef struct RClass mrb_class;
//@endcond
 
//================================================================
struct RBuiltinClass {
#if defined(MRBC_DEBUG)
  uint8_t obj_mark_[2];           
  const char *name;
#endif
 
  mrbc_sym sym_id;                
  unsigned int flag_builtin : 1;  
  unsigned int flag_nomethod : 1; 
  unsigned int flag_module : 1;   
  unsigned int flag_alias : 1;    
  uint8_t num_builtin_method;     
  struct RClass *super;           
 
  // --- Specific members ---
  union {
    struct RMethod *method_link;  
    struct RClass *aliased;       
  };
 
  const mrbc_sym *method_symbols;       
  const mrbc_func_t *method_functions;  
};
 
//================================================================
struct RBuiltinNoMethodClass {
#if defined(MRBC_DEBUG)
  uint8_t obj_mark_[2];           
  const char *name;
#endif
 
  mrbc_sym sym_id;                
  unsigned int flag_builtin : 1;  
  unsigned int flag_nomethod : 1; 
  unsigned int flag_module : 1;   
  unsigned int flag_alias : 1;    
  uint8_t num_builtin_method;     
  struct RClass *super;           
};
 
 
//================================================================
typedef struct RInstance {
  MRBC_OBJECT_HEADER;
 
  struct RClass *cls;           
  struct RKeyValueHandle ivar;  
  uint8_t data[];               
 
} mrbc_instance;
 
//@cond
typedef struct RInstance mrb_instance;
//@endcond
 
 
//================================================================
typedef struct RMethod {
  uint8_t  type;        
  uint8_t  c_func;      
  mrbc_sym sym_id;      
  union {
    struct IREP *irep;  
    mrbc_func_t func;   
  };
  union {
    struct RMethod *next;       
    struct RClass  *cls;        
  };
} mrbc_method;
 
 
//================================================================
struct MRBC_DEFINE_METHOD_LIST {
  const char *name;             
  const mrbc_func_t cfunc;      
};
 
 
/***** Global variables *****************************************************/
extern struct RClass * const mrbc_class_tbl[];
#include "_autogen_builtin_class.h"
 
// for old version compatibility.
#define mrbc_class_object ((struct RClass*)(&mrbc_class_Object))
 
 
/***** Function prototypes **************************************************/
//@cond
mrbc_class *mrbc_traverse_class_tree(mrbc_class *cls, mrbc_class *nest_buf[], int *nest_idx);
mrbc_class *mrbc_traverse_class_tree_skip(mrbc_class *nest_buf[], int *nest_idx);
mrbc_class *mrbc_define_class(struct VM *vm, const char *name, mrbc_class *super);
mrbc_class *mrbc_define_class_under(struct VM *vm, const mrbc_class *outer, const char *name, mrbc_class *super);
mrbc_class *mrbc_define_module(struct VM *vm, const char *name);
mrbc_class *mrbc_define_module_under(struct VM *vm, const mrbc_class *outer, const char *name);
void mrbc_define_method(struct VM *vm, mrbc_class *cls, const char *name, mrbc_func_t cfunc);
mrbc_value mrbc_instance_new(struct VM *vm, mrbc_class *cls, int size);
void mrbc_instance_delete(mrbc_value *v);
int mrbc_instance_setiv(mrbc_value *target, mrbc_sym sym_id, mrbc_value *v);
mrbc_value mrbc_instance_getiv(mrbc_value *target, mrbc_sym sym_id);
void mrbc_instance_clear_vm_id(mrbc_value *v);
int mrbc_obj_is_kind_of(const mrbc_value *obj, const mrbc_class *tcls);
mrbc_class *mrbc_find_method(mrbc_method *r_method, mrbc_class *cls, mrbc_sym sym_id);
mrbc_class *mrbc_get_class_by_name(const char *name);
mrbc_value mrbc_send(struct VM *vm, mrbc_value *v, int argc, mrbc_value *recv, const char *method_name, int n_params, ...);
void c_ineffect(struct VM *vm, mrbc_value v[], int argc);
int mrbc_run_mrblib(const void *bytecode);
void mrbc_init_class(void);
void mrbc_init_class_c(void);
void mrbc_init_class_mrblib(void);
//@endcond
 
 
/***** Inline functions *****************************************************/
 
//================================================================
static inline mrbc_class *find_class_by_object(const mrbc_value *obj)
{
  assert( mrbc_type(*obj) >= 0 );
  assert( mrbc_type(*obj) <= MRBC_TT_MAXVAL );
 
  mrbc_class *cls = mrbc_class_tbl[ mrbc_type(*obj) ];
  if( !cls ) {
    switch( mrbc_type(*obj) ) {
    case MRBC_TT_CLASS:         // fall through.
    case MRBC_TT_MODULE:        cls = obj->cls;                 break;
    case MRBC_TT_OBJECT:        cls = obj->instance->cls;       break;
    case MRBC_TT_EXCEPTION:     cls = obj->exception->cls;      break;
    default:
      assert(!"Invalid value type.");
    }
  }
 
  return cls;
}
 
 
#if MRBC_INSTANCE_DESTRUCTOR
//================================================================
static inline void mrbc_define_destructor( mrbc_class *cls, void (*destructor)(mrbc_value *) )
{
  assert( cls->flag_builtin == 0 );
  assert( cls->flag_module == 0 );
 
  cls->destructor = destructor;
}
#endif
 
 
//================================================================
static inline mrbc_value * mrbc_instance_getiv_p(mrbc_value *obj, mrbc_sym sym_id)
{
  return mrbc_kv_get( &obj->instance->ivar, sym_id );
}
 
 
//================================================================
static inline void mrbc_define_method_list(struct VM *vm, mrbc_class *cls, const struct MRBC_DEFINE_METHOD_LIST list[], int list_size)
{
  for( int i = 0; i < list_size; i++ ) {
    mrbc_define_method(vm, cls, list[i].name, list[i].cfunc);
  }
}
 
#ifdef __cplusplus
}
#endif
#endif