source: to-imperative/trunk/runtime/rf_char.cc @ 1106

#include "rf_char.ih"
#include "rf_expr.ih"
#include "rf_types.ih"
#include "rf_core.hh"

namespace rftype
{

Expr Char::create_expr (const WString& _wstr)
{
  size_t len = _wstr.get_length();
  const wchar_t* pstr = _wstr.get_data();

  Expr  e = Term::create_flat_expr(len);
  Term* p = e.get_first();

  while (len--)
    new(p++) Char(*pstr++);
  return e;
}

Expr Char::create_expr (char const* _str, char const* _locale /* = null */)
{
  char const* saved_locale = null;
  if (_locale != null) {

    saved_locale = setlocale(LC_CTYPE, null);
    setlocale(LC_CTYPE, _locale);
  }
  mbstate_t ps;
  char const* s = _str;
  size_t len = mbsrtowcs(null, &s, 0, &ps);
  if (len == (size_t)(-1)) FATAL("Error while converting a string");
  Expr e = Term::create_flat_expr(len);
  Term* p = e.get_first();
  s = _str;
  while (len-- > 0) {
    wchar_t wc;
    size_t l = mbrtowc(&wc, s, MB_CUR_MAX, &ps);
    new(p) Char(wc);
    p++; s += l;
  }
  if (_locale != null) setlocale(LC_CTYPE, saved_locale);
  return e;
}

static Expr terms_to_chars (Term const* _p, Term const* _q)
{
  static const Expr lp = Char::create_expr("(");
  static const Expr rp = Char::create_expr(")");

  Expr e = empty;

  for (; _p < _q; _p++)
  {
    if (_p->is_ref())
      e = e + lp + terms_to_chars(_p->get_first(), _p->get_last()) + rp;
    else
      e = e + Char::create_expr(WString(*_p));
  };

  return e;
}

Expr Char::to_chars (const Expr& _expr)
{
  return terms_to_chars(_expr.get_first(), _expr.get_last());
}

Expr Char::to_lower (const Expr& _expr)
{
  Term* p = _expr.get_first();
  Term* q = _expr.get_last();

  Expr  e = Term::create_expr(_expr.get_len());
  Term* r = e.get_first();
  
  for (; p < q; p++, r++)
    new(r) Char(towlower(((Char*)p)->uint_data2));

  return e;
}

Expr Char::to_upper (const Expr& _expr)
{
  Term* p = _expr.get_first();
  Term* q = _expr.get_last();

  Expr  e = Term::create_expr(_expr.get_len());
  Term* r = e.get_first();
  
  for (; p < q; p++, r++)
    new(r) Char(towupper(((Char*)p)->uint_data2));

  return e;
}

Expr Char::bytes_to_chars (const Expr& _expr)
{
  Term* p = _expr.get_first();
  Term* q = _expr.get_last();

  Expr  e = Term::create_expr(_expr.get_len());
  Term* r = e.get_first();
  
  uintptr_t temp;
  for (; p < q; p++, r++) {
    temp = uintptr_t(((Int32*)p)->to_int());
    new(r) Char(temp);
  };
  return e;
}

Expr Char::chars_to_bytes (const Expr& _expr)
{
  Term* p = _expr.get_first();
  Term* q = _expr.get_last();

  Expr  e = Term::create_expr(_expr.get_len());
  Term* r = e.get_first();
  for (; p < q; p++, r++) {
    new(r) Int32(((Char*)p)->uint_data2);
  }
  return e;
}

int Char::compare (Char const* _char1, Char const* _char2)
{
  if (_char1->uint_data2 == _char2->uint_data2) return 0;
  else if (_char1->uint_data2 < _char2->uint_data2) return -1;
  else return 1;
}

uint32_t Char::hash (Char const* _char)
{
  return _char->uint_data2;
}

pxx::WString Char::to_string (Char const* _char)
{
  wchar_t wc = _char->uint_data2;
  return pxx::WString(&wc, 1);
}

short_type_funcs_t Char::funcs = {
  null, // Char::ctor,
  null, // Char::dtor,
  null, // Char::eq,
  (int (*)(Term const*, Term const*))(Char::compare),
  (uint32_t (*)(Term const*))(Char::hash),
  (pxx::WString (*)(Term const*))(Char::to_string)
};

}