c_hash.c

Go to the documentation of this file.

 
/***** Feature test switches ************************************************/
/***** System headers *******************************************************/
//@cond
#include "vm_config.h"
#include <string.h>
#include <assert.h>
//@endcond
 
/***** Local headers ********************************************************/
#include "mrubyc.h"
 
/***** Constat values *******************************************************/
/***** Macros ***************************************************************/
/***** Typedefs *************************************************************/
/***** Function prototypes **************************************************/
/***** Local variables ******************************************************/
/***** Global variables *****************************************************/
/***** Signal catching functions ********************************************/
/***** Local functions ******************************************************/
/***** Global functions *****************************************************/
 
//================================================================
mrbc_value mrbc_hash_new(mrbc_vm *vm, int size)
{
  // Allocate handle and data buffer.
  mrbc_hash *hash = mrbc_alloc(vm, sizeof(mrbc_hash));
  mrbc_value *data = mrbc_alloc(vm, sizeof(mrbc_value) * size * 2);
 
  *hash = (mrbc_hash){
    MRBC_INIT_OBJECT_HEADER_DI(HA)
    .data_size = size * 2,
    .n_stored = 0,
    .data = data,
  };
 
  return mrbc_immediate_value(MRBC_TT_HASH, .hash = hash);
}
 
 
//================================================================
void mrbc_hash_delete(mrbc_value *hash)
{
  // TODO: delete other members (for search).
 
  mrbc_array_delete(hash);
}
 
 
//================================================================
mrbc_value * mrbc_hash_search(const mrbc_value *hash, const mrbc_value *key)
{
  mrbc_value *p1 = hash->hash->data;
  const mrbc_value *p2 = p1 + hash->hash->n_stored;
 
  while( p1 < p2 ) {
    if( mrbc_compare(p1, key) == 0 ) return p1;
    p1 += 2;
  }
 
  return NULL;
}
 
 
//================================================================
mrbc_value * mrbc_hash_search_by_id(const mrbc_value *hash, mrbc_sym sym_id)
{
  mrbc_value *p1 = hash->hash->data;
  const mrbc_value *p2 = p1 + hash->hash->n_stored;
 
  while( p1 < p2 ) {
    if( mrbc_type(*p1) == MRBC_TT_SYMBOL &&
        mrbc_symbol(*p1) == sym_id ) return p1;
    p1 += 2;
  }
 
  return NULL;
}
 
 
//================================================================
int mrbc_hash_set(mrbc_value *hash, mrbc_value *key, mrbc_value *val)
{
  mrbc_value *v = mrbc_hash_search(hash, key);
  int ret = 0;
  if( v == NULL ) {
    // set a new value
    if( (ret = mrbc_array_push(hash, key)) != 0 ) goto RETURN;
    ret = mrbc_array_push(hash, val);
 
  } else {
    // replace a value
    mrbc_decref(v);
    *v = *key;
    mrbc_decref(++v);
    *v = *val;
  }
 
 RETURN:
  return ret;
}
 
 
//================================================================
mrbc_value mrbc_hash_get(const mrbc_value *hash, const mrbc_value *key)
{
  mrbc_value *v = mrbc_hash_search(hash, key);
  return v ? *++v : mrbc_nil_value();
}
 
 
//================================================================
mrbc_value * mrbc_hash_get_p(const mrbc_value *hash, const mrbc_value *key)
{
  mrbc_value *v = mrbc_hash_search(hash, key);
  return v ? ++v : v;
}
 
 
//================================================================
mrbc_value mrbc_hash_remove(mrbc_value *hash, const mrbc_value *key)
{
  mrbc_value *v = mrbc_hash_search(hash, key);
  if( v == NULL ) return mrbc_nil_value();
 
  mrbc_decref(v);               // key
  mrbc_value val = v[1];        // value
 
  mrbc_hash *h = hash->hash;
  h->n_stored -= 2;
 
  memmove(v, v+2, (char*)(h->data + h->n_stored) - (char*)v);
 
  // TODO: re-index hash table if need.
 
  return val;
}
 
 
//================================================================
mrbc_value mrbc_hash_remove_by_id(mrbc_value *hash, mrbc_sym sym_id)
{
  mrbc_value *v = mrbc_hash_search_by_id(hash, sym_id);
  if( !v ) return mrbc_immediate_value(MRBC_TT_EMPTY);
 
  mrbc_value val = v[1];        // value
 
  mrbc_hash *h = hash->hash;
  h->n_stored -= 2;
 
  memmove(v, v+2, (char*)(h->data + h->n_stored) - (char*)v);
 
  // TODO: re-index hash table if need.
 
  return val;
}
 
 
//================================================================
void mrbc_hash_clear(mrbc_value *hash)
{
  mrbc_array_clear(hash);
 
  // TODO: re-index hash table if need.
}
 
 
//================================================================
int mrbc_hash_compare(const mrbc_value *v1, const mrbc_value *v2)
{
  if( v1->hash->n_stored != v2->hash->n_stored ) return 1;
 
  mrbc_value *d1 = v1->hash->data;
  for( int i = 0; i < mrbc_hash_size(v1); i++, d1++ ) {
    mrbc_value *d2 = mrbc_hash_search(v2, d1);  // check key
    if( d2 == NULL ) return 1;
    if( mrbc_compare( ++d1, ++d2 ) ) return 1;  // check data
  }
 
  return 0;
}
 
 
//================================================================
mrbc_value mrbc_hash_dup( mrbc_vm *vm, mrbc_value *src )
{
  mrbc_value ret = mrbc_hash_new(vm, mrbc_hash_size(src));
  mrbc_hash *h = src->hash;
 
  memcpy( ret.hash->data, h->data, sizeof(mrbc_value) * h->n_stored );
  ret.hash->n_stored = h->n_stored;
 
  mrbc_value *p1 = h->data;
  const mrbc_value *p2 = p1 + h->n_stored;
  while( p1 < p2 ) {
    mrbc_incref(p1++);
  }
 
  // TODO: dup other members.
 
  return ret;
}
 
 
 
 
//================================================================
static void c_hash_new(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_value ret = mrbc_hash_new(vm, 0);
  SET_RETURN(ret);
}
 
 
//================================================================
static void c_hash_get(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if( argc != 1 ) {
    mrbc_raise(vm, MRBC_CLASS(ArgumentError), "wrong number of arguments");
    return;
  }
 
  mrbc_value val = mrbc_hash_get(&v[0], &v[1]);
  mrbc_incref(&val);
  SET_RETURN(val);
}
 
 
//================================================================
static void c_hash_set(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if( argc != 2 ) {
    mrbc_raise(vm, MRBC_CLASS(ArgumentError), "wrong number of arguments");
    return;
  }
 
  mrbc_value *v1 = &v[1];
  mrbc_value *v2 = &v[2];
  mrbc_hash_set(v, v1, v2);
  mrbc_set_tt(v1, MRBC_TT_EMPTY);
  mrbc_set_tt(v2, MRBC_TT_EMPTY);
}
 
 
//================================================================
static void c_hash_clear(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_hash_clear(v);
}
 
 
//================================================================
static void c_hash_deconstruct_keys(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if (argc != 1) {
    mrbc_raise(vm, MRBC_CLASS(ArgumentError), "wrong number of arguments");
    return;
  }
  // For pattern matching - return self (not a copy)
}
 
 
//================================================================
static void c_hash_pat_values(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if( argc != 1 ) {
    mrbc_raise(vm, MRBC_CLASS(ArgumentError), "wrong number of arguments");
    return;
  }
 
  mrbc_value *keys = &v[1];
  int klen = mrbc_array_size(keys);
 
  for( int i = 0; i < klen; i++ ) {
    mrbc_value key = mrbc_array_get(keys, i);
    if( mrbc_hash_search(&v[0], &key) == NULL ) {
      SET_FALSE_RETURN();
      return;
    }
  }
 
  mrbc_value result = mrbc_array_new(vm, klen);
  for( int i = 0; i < klen; i++ ) {
    mrbc_value key = mrbc_array_get(keys, i);
    mrbc_value *found = mrbc_hash_search(&v[0], &key);
    mrbc_value val = found[1];
    mrbc_incref(&val);
    mrbc_array_push(&result, &val);
  }
 
  SET_RETURN(result);
}
 
 
//================================================================
static void c_hash_except_keys(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if( argc != 1 ) {
    mrbc_raise(vm, MRBC_CLASS(ArgumentError), "wrong number of arguments");
    return;
  }
 
  mrbc_value *excl_keys = &v[1];
  int klen = mrbc_array_size(excl_keys);
  mrbc_value result = mrbc_hash_new(vm, mrbc_hash_size(&v[0]));
  mrbc_hash_iterator ite = mrbc_hash_iterator_new(&v[0]);
 
  while( mrbc_hash_i_has_next(&ite) ) {
    mrbc_value *kv = mrbc_hash_i_next(&ite);
    int found = 0;
    for( int i = 0; i < klen; i++ ) {
      mrbc_value excl_key = mrbc_array_get(excl_keys, i);
      if( mrbc_compare(&kv[0], &excl_key) == 0 ) {
        found = 1;
        break;
      }
    }
    if( !found ) {
      mrbc_hash_set(&result, &kv[0], &kv[1]);
      mrbc_incref(&kv[0]);
      mrbc_incref(&kv[1]);
    }
  }
 
  SET_RETURN(result);
}
 
 
//================================================================
static void c_hash_dup(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_value ret = mrbc_hash_dup( vm, &v[0] );
 
  SET_RETURN(ret);
}
 
 
//================================================================
static void c_hash_delete(mrbc_vm *vm, mrbc_value v[], int argc)
{
  // TODO : now, support only delete(key) -> object
 
  mrbc_value ret = mrbc_hash_remove(v, v+1);
 
  // TODO: re-index hash table if need.
 
  SET_RETURN(ret);
}
 
 
//================================================================
static void c_hash_empty(mrbc_vm *vm, mrbc_value v[], int argc)
{
  int n = mrbc_hash_size(v);
 
  SET_BOOL_RETURN( !n );
}
 
 
//================================================================
static void c_hash_has_key(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_value *res = mrbc_hash_search(v, v+1);
 
  SET_BOOL_RETURN( res != NULL );
}
 
 
//================================================================
static void c_hash_has_value(mrbc_vm *vm, mrbc_value v[], int argc)
{
  int ret = 0;
  mrbc_hash_iterator ite = mrbc_hash_iterator_new(&v[0]);
 
  while( mrbc_hash_i_has_next(&ite) ) {
    mrbc_value *val = mrbc_hash_i_next(&ite) + 1;       // skip key, get value
    if( mrbc_compare(val, &v[1]) == 0 ) {
      ret = 1;
      break;
    }
  }
 
  SET_BOOL_RETURN( ret );
}
 
 
//================================================================
static void c_hash_key(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_value *ret = NULL;
  mrbc_hash_iterator ite = mrbc_hash_iterator_new(&v[0]);
 
  while( mrbc_hash_i_has_next(&ite) ) {
    mrbc_value *kv = mrbc_hash_i_next(&ite);
    if( mrbc_compare( &kv[1], &v[1]) == 0 ) {
      mrbc_incref( &kv[0] );
      ret = &kv[0];
      break;
    }
  }
 
  if( ret ) {
    SET_RETURN(*ret);
  } else {
    SET_NIL_RETURN();
  }
}
 
 
//================================================================
static void c_hash_keys(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_value ret = mrbc_array_new( vm, mrbc_hash_size(v) );
  mrbc_hash_iterator ite = mrbc_hash_iterator_new(v);
 
  while( mrbc_hash_i_has_next(&ite) ) {
    mrbc_value *key = mrbc_hash_i_next(&ite);
    mrbc_array_push(&ret, key);
    mrbc_incref(key);
  }
 
  SET_RETURN(ret);
}
 
 
//================================================================
static void c_hash_size(mrbc_vm *vm, mrbc_value v[], int argc)
{
  int n = mrbc_hash_size(v);
 
  SET_INT_RETURN(n);
}
 
 
//================================================================
static void c_hash_merge(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_value ret = mrbc_hash_dup( vm, &v[0] );
  mrbc_hash_iterator ite = mrbc_hash_iterator_new(&v[1]);
 
  while( mrbc_hash_i_has_next(&ite) ) {
    mrbc_value *kv = mrbc_hash_i_next(&ite);
    mrbc_hash_set( &ret, &kv[0], &kv[1] );
    mrbc_incref( &kv[0] );
    mrbc_incref( &kv[1] );
  }
 
  SET_RETURN(ret);
}
 
 
//================================================================
static void c_hash_merge_self(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_hash_iterator ite = mrbc_hash_iterator_new(&v[1]);
 
  while( mrbc_hash_i_has_next(&ite) ) {
    mrbc_value *kv = mrbc_hash_i_next(&ite);
    mrbc_hash_set( v, &kv[0], &kv[1] );
    mrbc_incref( &kv[0] );
    mrbc_incref( &kv[1] );
  }
}
 
 
//================================================================
static void c_hash_values(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_value ret = mrbc_array_new( vm, mrbc_hash_size(v) );
  mrbc_hash_iterator ite = mrbc_hash_iterator_new(v);
 
  while( mrbc_hash_i_has_next(&ite) ) {
    mrbc_value *val = mrbc_hash_i_next(&ite) + 1;
    mrbc_array_push(&ret, val);
    mrbc_incref(val);
  }
 
  SET_RETURN(ret);
}
 
 
//================================================================
static void c_hash_fetch(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if( argc < 1 || argc > 2 ) {
    mrbc_raise(vm, MRBC_CLASS(ArgumentError), "wrong number of arguments");
    return;
  }
 
  mrbc_value *val = mrbc_hash_search(v, v+1);
  if( val ) {
    mrbc_incref(++val);
    SET_RETURN(*val);
    return;
  }
 
  // key not found
  if( argc == 2 ) {
    // return default value
    mrbc_incref(&v[2]);
    SET_RETURN(v[2]);
    return;
  }
 
  // no default - raise
  mrbc_raise(vm, MRBC_CLASS(RuntimeError), "key not found");
}
 
 
#if MRBC_USE_STRING
//================================================================
static void c_hash_inspect(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if( mrbc_type(v[0]) == MRBC_TT_CLASS ) {
    mrbc_object_inspect(vm, v, argc);
    return;
  }
 
  mrbc_value ret = mrbc_string_new_cstr(vm, "{");
  mrbc_hash_iterator ite = mrbc_hash_iterator_new(v);
  int flag_first = 1;
 
  while( mrbc_hash_i_has_next(&ite) ) {
    if( !flag_first ) mrbc_string_append_cstr( &ret, ", " );
    flag_first = 0;
    mrbc_value *kv = mrbc_hash_i_next(&ite);
    mrbc_value s1;
 
    if (mrbc_type(*kv) == MRBC_TT_SYMBOL) {
      const char *s = mrbc_symid_to_str(kv->sym_id);
      mrbc_string_append_cstr( &ret, s );
      mrbc_string_append_cstr( &ret, ": " );
    } else {
      s1 = mrbc_send( vm, v, argc, &kv[0], "inspect", 0 );
      mrbc_string_append( &ret, &s1 );
      mrbc_string_delete( &s1 );
      mrbc_string_append_cstr( &ret, " => " );
    }
 
    s1 = mrbc_send( vm, v, argc, &kv[1], "inspect", 0 );
    mrbc_string_append( &ret, &s1 );
    mrbc_string_delete( &s1 );
  }
 
  mrbc_string_append_cstr( &ret, "}" );
 
  SET_RETURN(ret);
  return;
}
#endif
 
 
/* MRBC_AUTOGEN_METHOD_TABLE
 
  CLASS("Hash")
  FILE("_autogen_class_hash.h")
 
  METHOD( "new",        c_hash_new )
  METHOD( "[]",         c_hash_get )
  METHOD( "[]=",        c_hash_set )
  METHOD( "__except",   c_hash_except_keys )
  METHOD( "__pat_values", c_hash_pat_values )
  METHOD( "clear",      c_hash_clear )
  METHOD( "deconstruct_keys", c_hash_deconstruct_keys )
  METHOD( "dup",        c_hash_dup )
  METHOD( "delete",     c_hash_delete )
  METHOD( "empty?",     c_hash_empty )
  METHOD( "fetch",      c_hash_fetch )
  METHOD( "has_key?",   c_hash_has_key )
  METHOD( "has_value?", c_hash_has_value )
  METHOD( "key",        c_hash_key )
  METHOD( "keys",       c_hash_keys )
  METHOD( "size",       c_hash_size )
  METHOD( "length",     c_hash_size )
  METHOD( "count",      c_hash_size )
  METHOD( "merge",      c_hash_merge )
  METHOD( "merge!",     c_hash_merge_self )
  METHOD( "to_h",       c_ineffect )
  METHOD( "values",     c_hash_values )
#if MRBC_USE_STRING
  METHOD( "inspect",    c_hash_inspect )
  METHOD( "to_s",       c_hash_inspect )
#endif
*/
#include "_autogen_class_hash.h"