source: to-imperative/trunk/runtime/rf_short_int.cc @ 763

// $Source$
// $Revision: 763 $
// $Date: 2003-05-26 15:34:42 +0000 (Mon, 26 May 2003) $
// $Author: luba $

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

namespace rftype
{

unsigned ShortInt::compute_max_len ()
{
  intptr_t i   = INTPTR_MAX / 10000;
  unsigned len = 4;
  for ( ; i; i /= 10) len++;
  return len;
}

const unsigned ShortInt::max_len = compute_max_len();

Expr ShortInt::create_expr (intptr_t _n)
{
  Expr e = Term::create_expr(1);
  new(e.get_first()) ShortInt(_n);
  return e;
}


Expr ShortInt::create_expr (Expr& _expr, int _flag)
{
  Term* p = _expr.get_first();
  Term* q = _expr.get_last();
  int d = 0;
  intptr_t n = 0;

  if (p->get_type() == type_short_int) {
    n = ((ShortInt*)p)->to_int();
    if (n < 0) {
      n = -n;
      d = -1;
      _flag = -1;
    }
    else {
      _flag = 1;
      d = 1;
    }
  }
  if (p->get_type() == type_word) {
    d = 0;
  }
  if (p->get_type() == type_char) {
    d = _flag;
  }

  for (p += _flag * d; p < q; p++) {
    if (p->get_type() == type_short_int) {
      intptr_t n_temp = ((ShortInt*)p)->to_int() / 10;
      intptr_t k      = 10;
      
      while (n_temp) {
        n_temp /= 10;
        k *= 10;
      }

      n = n * k + ((ShortInt*)p)->to_int();
      
    }
    if (p->get_type() == type_char) {
      if (((Char*)p)->is_not_space()) 
        n = n * 10 + (((Char*)p)->to_wchar_t() - 48);
    }
    if (p->get_type() == type_word) {
      float n_word = 0;
      float k_word = 0.1;

      Word::NumIterator i = *((Word*)p);

      while (i.in_bounds()) {
        k_word *= 10;
        i++;
      }

      Word::NumIterator j = *((Word*)p);

      for (; j.in_bounds(); j++){       
        n_word += (*j) * k_word;
        k_word /= 10;
      } 
      n += size_t (n_word);                 
    }
  }
  if (-1 == _flag) n = -n;

  Expr e = Term::create_expr(1);
  new(e.get_first()) ShortInt(n);
  return e;
}

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

void ShortInt::dtor (uintptr_t)
{ }

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

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

pxx::WString ShortInt::to_string (uintptr_t _data) {
  intptr_t n = _data;
  int flag = 0;
   
  if (n < 0) {
    n = -n;
    flag = -1;
  }

  wchar_t str[max_len + 1];
  int i = max_len;

  if (!n) {
    str[i] = 48;
  }
  else {
    while (n) {
      str[i] = n % 10 + 48;
      n /= 10;
      i--; 
    };

    if (flag) {
      str[i] = '-'; 
    }
    else i++;
  }
  return pxx::WString(&str[i], max_len + 1 - i);
  
}

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

}