source: to-imperative/trunk/runtime/rf_word.ih @ 733

#ifndef __rf_word_ih__
#define __rf_word_ih__

#include "rf_word.hh"
#include "rf_common.ih"

#include <wctype.h>
#include <wchar.h>
#include <locale.h>

namespace rftype
{

using namespace rfrt ;

inline Word::Word (wchar_t const* _wstr) :
  Term (term_sym, type_word)
{
  size_t len = wcslen(_wstr);
  Header* h = static_cast<Header*>(
    allocator.allocate(sizeof(Header) + len * sizeof(wchar_t)));
  h->ref_count = 1;
  h->length = len;
  uint32_t hash = 0;
  for (size_t i = 0; i < len; i++) {
    h->content[i] = _wstr[i];
    hash = update_hash(hash, h->content + i, sizeof(wchar_t));
  }
  h->hash = finish_hash(hash);
  ptr_data2 = h;
}

inline Word::Word (char const* _str, char const* _locale /* = null */) :
  Term (term_sym, type_word)
{
  char const* saved_locale = null;
  if (_locale != null) {
    saved_locale = setlocale(LC_CTYPE, null);
    setlocale(LC_CTYPE, _locale);
  }
  char const* s = _str;
  mbstate_t ps;
  size_t len = mbsrtowcs(null, &s, 0, &ps);
//  if (len == (size_t)(-1)) throw_sys_error(errno);
  Header* h = static_cast<Header*>(
    allocator.allocate(sizeof(Header) + len * sizeof(wchar_t)));
  h->ref_count = 1;
  h->length = len;
  s = _str;
  uint32_t hash = 0;
  for (size_t i = 0; i < len; i++) {
    size_t l = mbrtowc(h->content + i, s, MB_CUR_MAX, &ps);
    s += l;
    hash = update_hash(hash, h->content + i, sizeof(wchar_t));
  }
  h->hash = finish_hash(hash);
  ptr_data2 = h;
  if (_locale != null) setlocale(LC_CTYPE, saved_locale);
}
  
inline Word::Word (Word const& _word) :
  Term (term_sym, type_word)
{
  ptr_data2 = _word.ptr_data2;
  Header* h = static_cast<Header*>(ptr_data2);
  h->ref_count++;
}
 
inline Word::~Word ()
{ 
  Header* h = static_cast<Header*>(ptr_data2);
  if (--(h->ref_count) == 0) allocator.deallocate(h);
}

inline Word& Word::operator = (Word const& _word)
{
  if (this != &_word) {
    Header* h = static_cast<Header*>(ptr_data2);
    if (--(h->ref_count) == 0) allocator.deallocate(h);
    ptr_data2 = _word.ptr_data2;
    h = static_cast<Header*>(ptr_data2);
    h->ref_count++;
  }
  return self;
}

inline size_t Word::get_len () {
  return static_cast<Header*>(ptr_data2)->length;
}

inline int Word::is_number () {
  int res = 1;
  size_t i = 0;
  Header* h = static_cast<Header*>(ptr_data2);

  if ((h->content[i]) == '-') res = -1; 
  if ((h->content[i]) == '+') res = 1; 
  if (res) i = 1;
  for (; i < h->length; i++) 
    if (iswdigit(h->content[i]) == 0) {
      res = 0; break; 
    }
  return res;
}

//the method is called only if is_number() function 
//has returned non-zero value
//

inline Word::NumIterator::NumIterator(Word const& _word) {
  Header* h = static_cast<Header*>(_word.ptr_data2);
  if (*(h->content) == '+' || *(h->content) == '-')
    iter = h->content + 1;
  else
    iter = h->content;
    bound = h->content + h->length;
  }

inline Word::NumIterator& Word::NumIterator::operator ++() {
  iter++;      
  return *this;
  };

inline Word::NumIterator const& Word::NumIterator::operator = (Word const& _word) {
  Header* h = static_cast<Header*>(_word.ptr_data2);
  if (*(h->content) == '+' || *(h->content) == '-')
    iter = h->content + 1;
    else
      iter = h->content;
    return *this;
  };

inline bool Word::NumIterator::in_bounds () {
  if (iter > bound ) return false;
  else return true;
}

inline const wchar_t Word::NumIterator::operator * () {
  return *iter;
}

#if 0
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;
}
#endif
}

#endif // __rf_word_ih__