source: to-imperative/trunk/runtime/rf_word.cc @ 731

#include "rf_word.ih"
#include "rf_expr.ih"
#include "rf_types.ih"

namespace rftype
{

using namespace rfrt ;

uintptr_t Word::ctor (uintptr_t _data)
{
  Header* h = reinterpret_cast<Header*>(_data);
  h->ref_count++;
  return _data;
}

void Word::dtor (uintptr_t _data)
{
  Header* h = reinterpret_cast<Header*>(_data);
  if (--(h->ref_count) == 0) allocator.deallocate(h);
}

bool Word::eq (uintptr_t _data1, uintptr_t _data2)
{
  Header* h1 = reinterpret_cast<Header*>(_data1);
  Header* h2 = reinterpret_cast<Header*>(_data2);
  if (h1 == h2) return true;
  else {
    if (hash(_data1) != hash(_data2)) return false;
    else if (h1->length != h2->length) return false;
    else if (wmemcmp(h1->content, h2->content, h1->length) == 0) return true;
    else return false;
  }
}
  
Expr Word::create_expr (wchar_t const* _wstr)
 {
  Expr e = Term::create_expr(1);
  Term* p = e.get_first();
  new(p) Word(_wstr);
  return e;
}

Expr Word::create_expr (char const* _str, char const* _locale /* = null */)
{
  Expr e = Term::create_expr(1);
  Term* p = e.get_first();
  new(p) Word(_str, _locale);
  return e;
}

int Word::compare (uintptr_t _data1, uintptr_t _data2)
{
  Header* h1 = reinterpret_cast<Header*>(_data1);
  Header* h2 = reinterpret_cast<Header*>(_data2);
  if (h1 == h2) return 0;
  else {
    int r = wmemcmp(h1->content, h2->content, pxx_min(h1->length, h2->length));
    if (r != 0) return r;
    else {
      if (h1->length == h2->length) return 0;
      else return h1->length > h2->length ? 1 : -1;
    }
  }
}

uint32_t Word::hash (uintptr_t _data)
{
  Header* h = reinterpret_cast<Header*>(_data);
  if (h->hash == 0xffffffff) {
    // Should never occur, because we always compute hash for words
    h->hash = compute_hash(h->content, h->length * sizeof(wchar_t));
  }
  return h->hash;
}

short_type_funcs_t Word::funcs = {
  Word::ctor,
  Word::dtor,
  Word::eq,
  Word::compare,
  Word::hash,
  null // Word::to_string
};

}