caraway/caraway/oop.c

#include "caraway.h"

static OOP boot_defclass( char *name, OOP super, int fields );
static void cw_create_symbol_table( int count, OOP *classes );

static OOP boot_classes[20];
static char *boot_class_names[20];
static int boot_class_count = -1;

inline OOP cw_alloc_oop( unsigned long flags );
inline OOP cw_alloc_oop2();
inline OOP cw_new_instance( OOP klass, unsigned long fields );
inline OOP cw_new_instance( OOP klass, unsigned long fields );
inline OOP cw_new_instance2( OOP klass );

inline OOP cw_alloc_oop( unsigned long flags )
{
  OOP oop;

  oop = ALLOC(struct OOP);
  oop->flags = flags;
  oop->klass = 0;
  oop->ptr.oops = 0;
  return oop;
}

inline OOP cw_alloc_oop2()
{
  return cw_alloc_oop(0);
}

inline OOP cw_new_instance( OOP klass, unsigned long fields )
{
  OOP oop;

  oop = cw_alloc_oop2();
  oop->ptr.oops = ALLOC_N(OOP, fields);
  return oop;
}

inline void cw_init_fields( OOP oop, long size )
{
  int i, op;

  oop->ptr.oops = ALLOC_N(OOP, size);
  op = HAS_OPSIZE(oop);
  for (i = 0; i < size; i++)
    IV_SET(oop, op?i+1:i, Pnil);
}

void cw_init_dictionary()
{
  //create_classes_pass1 ();
  cw_init_proto_oops();

  /*
  init_smalltalk_dictionary ();

  create_classes_pass2 ();

  add_smalltalk ("KernelFilePath",
                 _gst_string_new (_gst_kernel_file_default_path));

  init_runtime_objects ();

  _gst_tenure_all_survivors ();
  */
}

void cw_init_proto_oops()
{
  OOP metaclass;

  // まず・髟阡惨霙譽?薀垢涼羶箸魘?悩遒
  // 巳苳餐阿魯轡鵐椒襪吠儡垢気譴襪????シンボルテ・踉札屮襪砲賄佻燭気譴覆
  // クラスプロパティはSmalltalkで定義したときにセットする
  CWObject = boot_defclass("Object", 0, Object_FIELD_SIZE);
  CWBehavior = boot_defclass("Behavior", CWObject, Behavior_FIELD_SIZE);
  CWClassDescription = boot_defclass("ClassDescription", CWBehavior,
                                     ClassDescription_FIELD_SIZE);
  CWClass = boot_defclass("Class", CWClassDescription, Class_FIELD_SIZE);
  CWMetaclass = boot_defclass("Metaclass", CWClassDescription,
                              Metaclass_FIELD_SIZE);
  CWMethodDictionary = boot_defclass("MethodDictionary", CWObject, 0);
  CWString = boot_defclass("String", CWObject, 0);
  CWByteString = boot_defclass("ByteString", CWString, 0);
  CWSymbol = boot_defclass("Symbol", CWString, 0);
  CWByteSymbol = boot_defclass("ByteSymbol", CWSymbol, 0);
  CWArray = boot_defclass("Array", CWObject, 1);
  CWMethodDictionary = boot_defclass("MethodDictionary", CWObject, 0);
  CWNameSpace = boot_defclass("NameSpace", CWObject, Namespace_FIELD_SIZE);
  CWNamedNameSpace = boot_defclass("NamedNameSpace", CWNameSpace,
                                   NamedNamespace_FIELD_SIZE);
  CWClassNameSpace = boot_defclass("ClassNameSpace", CWNameSpace,
                                   ClassNamespace_FIELD_SIZE);
  CWVariableBinding = boot_defclass("VariableBinding", CWObject,
                                    VariableBinding_FIELD_SIZE);

  // メタクラスを巳苳餐斡?屬離?薀好螢好箸謀佻
  metaclass = cw_make_metaclass(CWObject, CWClass);
  metaclass = cw_make_metaclass(CWBehavior, metaclass);
  metaclass = cw_make_metaclass(CWClassDescription, metaclass);
  cw_make_metaclass(CWClass, metaclass);
  cw_make_metaclass(CWMetaclass, metaclass);

  // ??，縫轡鵐椒襯董??ブルを生成
  // シンボルテ・踉札屮襪鯀犧遒垢覺愎瑤鰺儖佞靴覆い
  // う髟阡擦箸?WeakArrayに変換する
  // シンボルテ・踉札屮襪寮言?紂???いままでのシンボルを登録する
  // 同時に各シンボルのクラスをCWByteSymbolにセットする
  cw_create_symbol_table(boot_class_count, boot_classes);

  // ??，縫肇奪廛譽戰襪量??前空間を生成
  // 生成後・髟阡札屐??トストラップのクラスを各巳苳餐斡?屬縫札奪箸垢
  //cw_create_root_namespace();

  //CWProcessor = cw_alloc_oop();

  //printf("init proto oop completed. syms - %d\n", SML2INT(Array_tally(CWBootSymbols)));
}

static OOP boot_defclass( char *name, OOP super, int fields )
{
  OOP oop;

  oop = cw_class_boot(super, fields);
  boot_classes[++boot_class_count] = oop;
  boot_class_names[boot_class_count] = name;
  return oop;
}

OOP cw_class_boot( OOP super, int fields )
{
  if (super) {
    /* adjust the number of instance variables to account for inheritance */
    fields += FL_FIELD_SIZE(FORMAT(super));
    Behavior_subclasses(super) = INT2SML(SML2INT(Behavior_subclasses(super)) + 1);
  }

  NEWOOP(klass);
  INIT_FIELDS(klass, CLOOP_FIELD_SIZE); // class object fields
  klass->flags = FL_PTR | CLOOP_FIELD_SIZE << FIELD_LSHIFT;
  klass->klass = Pnil;
  Behavior_superclass(klass) = super;
  Behavior_format(klass) = INT2SML(fields << FIELD_LSHIFT-2);
  Behavior_subclasses(klass) = INT2SML(0);
  return klass;
}

char *cw_class_name( OOP klass )
{
  return BYTESTR_PTR(Class_name(klass));
}

/*
 * Metaclass world
 *
 * (name) ... metaclass
 * --->   ... inherit relation
 * ===>   ... metaclass relation
 *
 *
 *                        Object ===============> (Object)
 *                          ^                        ^
 *                          |                        |
 *                       Behavior =============> (Behavior)
 *                          ^                        ^
 *                          |                        |
 *                   ClassDescription =====> (ClassDescription)
 *                          ^                       ^  ^
 *                          |                       |  |
 *                          |           +-----------+  +-----------+
 *                          |           |                          |
 *                        Class ===> (Class)   Metaclass ===> (Metaclass)
 *                          ^                      ^
 *                          |                      |
 *   Object ==========> (Object) ==================+
 *     ^                   ^                       |
 *     |                   |                       |
 *   OtherClass ===> (OtherClass) =================+
 *
 */
OOP cw_make_metaclass( OOP oop, OOP super )
{
        OOP metasuper = NULL;
        OOP klass;

  klass = cw_class_boot(super, Metaclass_FIELD_SIZE);
        oop->klass = klass;
        metasuper = super->klass;
        /* metaclass of a superclass may be NULL at boot time */
        if (metasuper)
    klass->klass = metasuper;
        return klass;
}

static void cw_create_symbol_table( int count, OOP *classes )
{
  OOP oop, sym;
  int i;

  CWBootSymbols = cw_array_new(100);
  CWBootClasses = cw_array_new(30);
  for (i = 0; i < count; i++) {
    oop = classes[i];
    sym = cw_boot_intern(boot_class_names[i]);
    Class_name(oop) = sym;
    cw_array_add(CWBootClasses, oop);
  }
}

/*
static void cw_create_root_namespace()
{
  CWRootNameSpace = cw_define_namespace();
  core = cw_define_namespace(CWRootNameSpace);
}
*/

/*
 * Returns value of instance variable at index.
 * If indexed type of the oop is bytes, returns a byte as SmallInteger.
 */
OOP cw_iv_get( OOP oop, long index )
{
  if (HAS_PTR(oop)) {
    if (HAS_OPSIZE(oop))
      index++;
    return IV_GET(oop, FL_SP_FIELD_SIZE(oop) + index);
  } else
    return UINT2NUM(cw_byte_get(oop, index));
}

/*
 * Sets the value for instance variable at index.
 * If indexed type of the oop is bytes, sets the value as unsigned char.
 */
void cw_iv_set( OOP oop, long index, OOP val )
{
  if (HAS_PTR(oop)) {
    if (HAS_OPSIZE(oop))
      index++;
    IV_SET(oop, FL_SP_FIELD_SIZE(oop) + index, val);
  } else
    cw_byte_set(oop, index, (unsigned char)NUM2UINT(val));
}

/*
 * Returns value of indexed instance variable at index.
 */
OOP cw_object_get( OOP oop, long index )
{
  if (HAS_OPSIZE(oop))
    index++;
  return IV_GET(oop, FL_CL_FIELD_SIZE(oop) + index);
}

/*
 * Sets the value for indexed instance variable at index.
 */
void cw_object_set( OOP oop, long index, OOP val )
{
  if (HAS_OPSIZE(oop))
    index++;
  IV_SET(oop, FL_CL_FIELD_SIZE(oop) + index, val);
}

/*
 * Returns a byte of indexed instance variable at index.
 */
unsigned char cw_byte_get( OOP oop, long index )
{
  if (HAS_OPSIZE(oop))
    index += SIZEOF_LONG;
  return BYTE_GET(oop, index);
}

/*
 * Sets the value for indexed instance variable at index.
 */
void cw_byte_set( OOP oop, long index, unsigned char val )
{
  if (HAS_OPSIZE(oop))
    index += SIZEOF_LONG;
  BYTE_SET(oop, index, val);
}

void cw_swap( OOP oop1, OOP oop2 )
{
  struct OOP tmp;

  tmp = *oop2;
  *oop2 = *oop1;
  *oop1 = tmp;
}

OOP cw_byte_string_new( const char *ptr, long len )
{
  NEWOOP(str);
  BYTESSETUP(str, CWByteString, 0, len);
  if (HAS_OPSIZE(str))
    memcpy(str->ptr.oops+1, ptr, len);
  else
    memcpy(str->ptr.oops, ptr, len);
  return str;
}

OOP cw_byte_string_new2( const char *ptr )
{
  return cw_byte_string_new(ptr, strlen(ptr));
}

int cw_byte_string_hash( OOP str )
{
  int len, midLeft, midRight, nextToLast, firstc, mlc, mrc, nlc, lastc, hash;

  len = FIELD_SIZE(str);
  if (len == 0) {
    hash = 0;
  } else {
    if (len == 1) {
      midLeft = midRight = nextToLast = 1;
    } else {
      midLeft = len >> 1;
      midRight = midLeft + 1;
      nextToLast = len - 1;
    }
    firstc = cw_byte_get(str, 0);
    mlc = cw_byte_get(str, midLeft-1);
    mrc = cw_byte_get(str, midRight-1);
    nlc = cw_byte_get(str, nextToLast-1);
    lastc = cw_byte_get(str, len-1);
    hash = mrc + (mrc + len << 8) +
      ((firstc + nlc & 0x3fff) << 12) + (nlc << 2) +
      ((lastc & 0x07ff) << 16) + (firstc + lastc << 4) +
      ((mlc & 0xff) << 20) + (mlc << 6);
  }
  return hash;
}
/*
OOP cw_object_array_new( long size )
{
  int i, op;

  NEWOOP(ary);
  IDXSETUP(ary, CWObjectArray, 0, size);
  op = HAS_OPSIZE(ary);
  for (i = 0; i < size; i++)
    ary->ptr.oops[op?i+1:i] = Pnil;
  return ary;
}
*/
OOP cw_array_new( long size )
{
  int i, op;

  NEWOOP(ary);
  IDXSETUP(ary, CWArray, FL_PTR, size);
  op = HAS_OPSIZE(ary);
  for (i = 0; i < size; i++)
    ary->ptr.oops[op?i+1:i] = Pnil;
  Array_tally(ary) = INT2SML(0);
  return ary;
}

void cw_array_add( OOP ary, OOP obj )
{
  long i;
  for (i = 0; i < SML2INT(Array_tally(ary)); i++) {
    if (obj == cw_object_get(ary, i))
      return;
  }
  Array_tally(ary) = INT2SML(SML2INT(Array_tally(ary))+1);
  cw_iv_set(ary, SML2INT(Array_tally(ary)), obj);
}

OOP cw_uint2inum( unsigned long n )
{
  if (POSSMLABLE(n)) return LONG2SML(n);
  //return rb_uint2big(n);
}

OOP cw_int2inum( long n )
{
  if (SMLABLE(n)) return LONG2SML(n);
  //return rb_int2big(n);
}

// float, largeinteger
long cw_num2long( OOP oop )
{
  if (IS_SMLINT(oop)) return SML2LONG(oop);
  return NUM2LONG(oop);
}

unsigned long cw_num2ulong( OOP oop )
{
  return (unsigned long)cw_num2long(oop);
}


OOP cw_boot_intern( char *str )
{
  OOP sym;

  if (sym = cw_boot_lookup(str))
    return sym;
  sym = cw_byte_symbol_new2(str);
  cw_array_add(CWBootSymbols, sym);
  return sym;
}

OOP cw_boot_lookup( char *str )
{
  int i;
  OOP sym, sym2;

  sym2 = cw_byte_symbol_new2(str);
  for (i = 0; i < SML2INT(Array_tally(CWBootSymbols)); i++) {
    sym = cw_object_get(CWBootSymbols, i);
    if (sym != Pnil && sym->klass == CWByteSymbol &&
        cw_byte_symbol_cmp(sym, sym2))
      return sym;
  }
  return Pnil;
}

int cw_byte_string_cmp( OOP str, OOP other )
{
  int size, i;

  size = FIELD_SIZE(str);
  if (size != FIELD_SIZE(other)) return 0;
  for (i = 0; i < size; i++) {
    if (cw_byte_get(str, i) != cw_byte_get(other, i))
      return 0;
  }
  return 1;
}

/*
unsigned long cw_symbol_table_size()
{
  unsigned long size = 0;
  long i;
  OOP ary;

  for (i = 0; i < FIELD_SIZE(CWBootSymbolTable); i++) {
    ary = cw_object_get(CWSymbolTable, i);
    size += FIELD_SIZE(ary);
  }
  return size;
}
*/
OOP cw_byte_symbol_new( const char *ptr, long len )
{
  OOP sym;

  sym = cw_byte_string_new(ptr, len);
  sym->klass = CWByteSymbol;
  return sym;
}

OOP cw_byte_symbol_new2( const char *ptr )
{
  return cw_byte_symbol_new(ptr, strlen(ptr));
}

OOP cw_method_dictionary_new( long size )
{
  NEWOOP(dict);
  IDXSETUP(dict, CWMethodDictionary, 0, size);
  return dict;
}

static int cw_method_dictionary_find_index( OOP dict, OOP sym );

OOP cw_method_dictionary_get( OOP dict, OOP sym )
{
  int idx;

  idx = cw_method_dictionary_find_index(dict, sym);
  if (idx < 0)
    return Pnil;
  return cw_object_get(dict, idx+1);
}

static int cw_method_dictionary_find_index( OOP dict, OOP sym )
{
  int size, high, low = 0, idx, hash, probe_hash;
  OOP probe;

  size = FIELD_SIZE(sym);
  high = size - 1;
  if (high < 20) {
    while (low <= high) {
      if (sym == cw_object_get(dict, low))
        return low;
      low += 2;
    }

  } else if (low >= high) {
    return -1;

  } else {
    // binary search
    while (1) {
      idx = (low + high) >> 1 | 1;
      if ((probe = cw_object_get(dict, idx)) == sym) return idx;
      hash = cw_byte_symbol_hash(sym);
      probe_hash = cw_byte_symbol_hash(probe);
      if (probe_hash < hash) {
        low = idx + 2;
      } else {
        if (probe_hash > hash) {
          high = idx - 2;
        } else {
          low = idx;
          do {
            low -= 2;
            if (low < 0) return -1;
            if ((probe = cw_object_get(dict, low)) == sym) return low;
          } while (cw_byte_symbol_hash(probe) == hash);
          low = idx;
          do {
            low += 2;
            if (low > high) return -1;
            if ((probe = cw_object_get(dict, low)) == sym) return low;
          } while (cw_byte_symbol_hash(probe) == hash);
          return -1;
        }
      }
    }
  }
  return -1;
}

void cw_method_dictionary_set( OOP dict, OOP sym, OOP mth )
{
  int idx, hash, probe_hash, i, j, size, insert;
  OOP new, probe;

  idx = cw_method_dictionary_find_index(dict, sym);
  if (idx >= 0) {
    cw_object_set(dict, idx+1, mth);
  } else {
    size = FIELD_SIZE(dict);
    hash = cw_byte_symbol_hash(sym);
    new = cw_method_dictionary_new(size+2);
    for (i = 0, j = 0, insert = -1; i < size; i += 2, j += 2) {
      probe = cw_object_get(dict, i);
      probe_hash = cw_byte_symbol_hash(probe);
      if (insert < 0 && hash < probe_hash) {
        insert = i;
        j += 2;
      }
      cw_object_set(new, j, probe);
      cw_object_set(new, j+1, cw_object_get(dict, i+1));
    }
    if (insert < 0)
      insert = size == 0 ? 0 : i + 2;
    cw_object_set(new, insert, sym);
    cw_object_set(new, insert+1, mth);
    cw_swap(dict, new);
  }
}

int _main( int argc, char **argv )
{
  OOP dict;

  cw_init_proto_oops();

  /*
  // method dictionary test
  dict = cw_method_dictionary_new(0);
  cw_method_dictionary_set(dict, cw_boot_intern("add"), Pnil);
  cw_method_dictionary_set(dict, cw_boot_intern("add1"), Pnil);
  printf("dict field size = %d\n", FIELD_SIZE(dict));
  printf("#add at %d\n", cw_method_dictionary_find_index(dict, cw_boot_intern("add")));
  printf("#add1 at %d\n", cw_method_dictionary_find_index(dict, cw_boot_intern("add1")));
  */
  return 0;
}
