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

#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_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(((ShortInt*)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) ShortInt(((Char*)p)->uint_data2);
  }
  return e;
}

uintptr_t Char::ctor (uintptr_t _data)
{
  return _data;
}

void Char::dtor (uintptr_t)
{}

int Char::compare (uintptr_t _data1, uintptr_t _data2)
{
  if (_data1 == _data2) return 0;
  else if (_data1 < _data2) return -1;
  else return 1;
}

uint32_t Char::hash (uintptr_t _data)
{
  return _data;
}

pxx::WString Char::to_string (uintptr_t _data)
{
  wchar_t wc = _data;
  return pxx::WString(&wc, 1);
}

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

}