Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 412 insertions, 0 deletions

diff --git a/kjs/value.cpp b/kjs/value.cpp
new file mode 100644
index 000000000..e95756c48
--- /dev/null
+++ b/kjs/value.cpp
@@ -0,0 +1,412 @@
+// -*- c-basic-offset: 2 -*-
+/*
+ *  This file is part of the KDE libraries
+ *  Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
+ *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
+ *  Copyright (C) 2003 Apple Computer, Inc.
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Library General Public License
+ *  along with this library; see the file COPYING.LIB.  If not, write to
+ *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ *  Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "value.h"
+#include "object.h"
+#include "types.h"
+#include "interpreter.h"
+
+#include <assert.h>
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+
+#include "internal.h"
+#include "collector.h"
+#include "operations.h"
+#include "error_object.h"
+#include "nodes.h"
+#include "simple_number.h"
+
+using namespace KJS;
+
+// ----------------------------- ValueImp -------------------------------------
+
+ValueImp::ValueImp() :
+  refcount(0),
+  // Tell the garbage collector that this memory block corresponds to a real object now
+  _flags(VI_CREATED)
+{
+  //fprintf(stderr,"ValueImp::ValueImp %p\n",(void*)this);
+}
+
+ValueImp::~ValueImp()
+{
+  //fprintf(stderr,"ValueImp::~ValueImp %p\n",(void*)this);
+  _flags |= VI_DESTRUCTED;
+}
+
+void ValueImp::mark()
+{
+  //fprintf(stderr,"ValueImp::mark %p\n",(void*)this);
+  _flags |= VI_MARKED;
+}
+
+bool ValueImp::marked() const
+{
+  // Simple numbers are always considered marked.
+  return SimpleNumber::is(this) || (_flags & VI_MARKED);
+}
+
+void ValueImp::setGcAllowed()
+{
+  //fprintf(stderr,"ValueImp::setGcAllowed %p\n",(void*)this);
+  // simple numbers are never seen by the collector so setting this
+  // flag is irrelevant
+  if (!SimpleNumber::is(this))
+    _flags |= VI_GCALLOWED;
+}
+
+void* ValueImp::operator new(size_t s)
+{
+  return Collector::allocate(s);
+}
+
+void ValueImp::operator delete(void*)
+{
+  // Do nothing. So far.
+}
+
+bool ValueImp::toUInt32(unsigned&) const
+{
+  return false;
+}
+
+// ECMA 9.4
+int ValueImp::toInteger(ExecState *exec) const
+{
+  unsigned i;
+  if (dispatchToUInt32(i))
+    return static_cast<int>(i);
+  double d = roundValue(exec, Value(const_cast<ValueImp*>(this)));
+  if (isInf(d))
+    return INT_MAX;
+  return static_cast<int>(d);
+}
+
+int ValueImp::toInt32(ExecState *exec) const
+{
+  unsigned i;
+  if (dispatchToUInt32(i))
+    return (int)i;
+
+  double d = roundValue(exec, Value(const_cast<ValueImp*>(this)));
+  if (isNaN(d) || isInf(d) || d == 0.0)
+    return 0;
+  double d32 = fmod(d, D32);
+
+  //Make sure we use the positive remainder. This matters since this may be
+  //less than MIN_INT (but still < 2^32), and we don't want the cast to clamp.
+  if (d32 < 0)
+    d32 += D32;
+
+  if (d32 >= D32 / 2.0)
+    d32 -= D32;
+
+  return static_cast<int>(d32);
+}
+
+unsigned int ValueImp::toUInt32(ExecState *exec) const
+{
+  unsigned i;
+  if (dispatchToUInt32(i))
+    return i;
+
+  double d = roundValue(exec, Value(const_cast<ValueImp*>(this)));
+  if (isNaN(d) || isInf(d) || d == 0.0)
+    return 0;
+  double d32 = fmod(d, D32);
+
+  if (d32 < 0)
+    d32 += D32;
+
+  //6.3.1.4 Real floating and integer
+  // 50) The remaindering operation performed when a value of integer type is
+  //   converted to unsigned type need not be performed when a value of real
+  //   floating type is converted to unsigned type. Thus, the range of
+  //   portable real floating values is (-1, Utype_MAX+1).
+  return static_cast<unsigned int>(d32);
+}
+
+unsigned short ValueImp::toUInt16(ExecState *exec) const
+{
+  unsigned i;
+  if (dispatchToUInt32(i))
+    return (unsigned short)i;
+
+  double d = roundValue(exec, Value(const_cast<ValueImp*>(this)));
+  double d16 = fmod(d, D16);
+
+  // look at toUInt32 to see why this is necesary
+  int t_int = static_cast<int>(d16);
+  return static_cast<unsigned short>(t_int);
+}
+
+// Dispatchers for virtual functions, to special-case simple numbers which
+// won't be real pointers.
+
+Type ValueImp::dispatchType() const
+{
+  if (SimpleNumber::is(this))
+    return NumberType;
+  return type();
+}
+
+Value ValueImp::dispatchToPrimitive(ExecState *exec, Type preferredType) const
+{
+  if (SimpleNumber::is(this))
+    return Value(const_cast<ValueImp *>(this));
+  return toPrimitive(exec, preferredType);
+}
+
+bool ValueImp::dispatchToBoolean(ExecState *exec) const
+{
+  if (SimpleNumber::is(this))
+    return SimpleNumber::value(this);
+  return toBoolean(exec);
+}
+
+double ValueImp::dispatchToNumber(ExecState *exec) const
+{
+  if (SimpleNumber::is(this))
+    return SimpleNumber::value(this);
+  return toNumber(exec);
+}
+
+UString ValueImp::dispatchToString(ExecState *exec) const
+{
+  if (SimpleNumber::is(this))
+    return UString::from(SimpleNumber::value(this));
+  return toString(exec);
+}
+
+Object ValueImp::dispatchToObject(ExecState *exec) const
+{
+  if (SimpleNumber::is(this))
+    return static_cast<const NumberImp *>(this)->NumberImp::toObject(exec);
+  return toObject(exec);
+}
+
+bool ValueImp::dispatchToUInt32(unsigned& result) const
+{
+  if (SimpleNumber::is(this)) {
+    long i = SimpleNumber::value(this);
+    if (i < 0)
+      return false;
+    result = (unsigned)i;
+    return true;
+  }
+  return toUInt32(result);
+}
+
+// ------------------------------ Value ----------------------------------------
+
+Value::Value(ValueImp *v)
+{
+  rep = v;
+#ifdef DEBUG_COLLECTOR
+  assert (!(rep && !SimpleNumber::is(rep) && *((uint32_t *)rep) == 0 ));
+  assert (!(rep && !SimpleNumber::is(rep) && rep->_flags & ValueImp::VI_MARKED));
+#endif
+  if (v)
+  {
+    v->ref();
+    //fprintf(stderr, "Value::Value(%p) imp=%p ref=%d\n", this, rep, rep->refcount);
+    v->setGcAllowed();
+  }
+}
+
+Value::Value(const Value &v)
+{
+  rep = v.imp();
+#ifdef DEBUG_COLLECTOR
+  assert (!(rep && !SimpleNumber::is(rep) && *((uint32_t *)rep) == 0 ));
+  assert (!(rep && !SimpleNumber::is(rep) && rep->_flags & ValueImp::VI_MARKED));
+#endif
+  if (rep)
+  {
+    rep->ref();
+    //fprintf(stderr, "Value::Value(%p)(copying %p) imp=%p ref=%d\n", this, &v, rep, rep->refcount);
+  }
+}
+
+Value::~Value()
+{
+  if (rep)
+  {
+    rep->deref();
+    //fprintf(stderr, "Value::~Value(%p) imp=%p ref=%d\n", this, rep, rep->refcount);
+  }
+}
+
+Value& Value::operator=(const Value &v)
+{
+  ValueImp *tmpRep = v.imp();
+
+  //Avoid the destruction of the object underneath us by
+  //incrementing the reference on it first
+  if (tmpRep) {
+    tmpRep->ref();
+    //fprintf(stderr, "Value::operator=(%p)(copying %p) imp=%p ref=%d\n", this, &v, tmpRep, tmpRep->refcount);
+  }
+
+  if (rep) {
+    rep->deref();
+    //fprintf(stderr, "Value::operator=(%p)(copying %p) old imp=%p ref=%d\n", this, &v, rep, rep->refcount);
+  }
+  rep = tmpRep;
+
+  return *this;
+}
+
+// ------------------------------ Undefined ------------------------------------
+
+Undefined::Undefined() : Value(UndefinedImp::staticUndefined)
+{
+}
+
+Undefined Undefined::dynamicCast(const Value &v)
+{
+  if (!v.isValid() || v.type() != UndefinedType)
+    return Undefined(0);
+
+  return Undefined();
+}
+
+// ------------------------------ Null -----------------------------------------
+
+Null::Null() : Value(NullImp::staticNull)
+{
+}
+
+Null Null::dynamicCast(const Value &v)
+{
+  if (!v.isValid() || v.type() != NullType)
+    return Null(0);
+
+  return Null();
+}
+
+// ------------------------------ Boolean --------------------------------------
+
+Boolean::Boolean(bool b)
+  : Value(b ? BooleanImp::staticTrue : BooleanImp::staticFalse)
+{
+}
+
+bool Boolean::value() const
+{
+  assert(rep);
+  return ((BooleanImp*)rep)->value();
+}
+
+Boolean Boolean::dynamicCast(const Value &v)
+{
+  if (!v.isValid() || v.type() != BooleanType)
+    return static_cast<BooleanImp*>(0);
+
+  return static_cast<BooleanImp*>(v.imp());
+}
+
+// ------------------------------ String ---------------------------------------
+
+String::String(const UString &s) : Value(new StringImp(s))
+{
+#ifndef NDEBUG
+  if (s.isNull())
+    fprintf(stderr, "WARNING: KJS::String constructed from null string\n");
+#endif
+}
+
+UString String::value() const
+{
+  assert(rep);
+  return ((StringImp*)rep)->value();
+}
+
+String String::dynamicCast(const Value &v)
+{
+  if (!v.isValid() || v.type() != StringType)
+    return String(0);
+
+  return String(static_cast<StringImp*>(v.imp()));
+}
+
+// ------------------------------ Number ---------------------------------------
+
+Number::Number(int i)
+  : Value(SimpleNumber::fits(i) ? SimpleNumber::make(i) : new NumberImp(static_cast<double>(i))) { }
+
+Number::Number(unsigned int u)
+  : Value(SimpleNumber::fits(u) ? SimpleNumber::make(u) : new NumberImp(static_cast<double>(u))) { }
+
+Number::Number(double d)
+#if defined(__alpha) && !defined(_IEEE_FP)
+  // check for NaN first if we werent't compiled with -mieee on Alpha
+ : Value(KJS::isNaN(d) ? NumberImp::staticNaN : (SimpleNumber::fits(d) ? SimpleNumber::make((long)d) : new NumberImp(d))) { }
+#else
+ : Value(SimpleNumber::fits(d) ? SimpleNumber::make((long)d) : (KJS::isNaN(d) ? NumberImp::staticNaN : new NumberImp(d))) { }
+#endif
+
+Number::Number(long int l)
+  : Value(SimpleNumber::fits(l) ? SimpleNumber::make(l) : new NumberImp(static_cast<double>(l))) { }
+
+Number::Number(long unsigned int l)
+  : Value(SimpleNumber::fits(l) ? SimpleNumber::make(l) : new NumberImp(static_cast<double>(l))) { }
+
+Number Number::dynamicCast(const Value &v)
+{
+  if (!v.isValid() || v.type() != NumberType)
+    return Number((NumberImp*)0);
+
+  return Number(static_cast<NumberImp*>(v.imp()));
+}
+
+double Number::value() const
+{
+  if (SimpleNumber::is(rep))
+    return (double)SimpleNumber::value(rep);
+  assert(rep);
+  return ((NumberImp*)rep)->value();
+}
+
+int Number::intValue() const
+{
+  if (SimpleNumber::is(rep))
+    return SimpleNumber::value(rep);
+  return (int)((NumberImp*)rep)->value();
+}
+
+bool Number::isNaN() const
+{
+  return rep == NumberImp::staticNaN;
+}
+
+bool Number::isInf() const
+{
+  if (SimpleNumber::is(rep))
+    return false;
+  return KJS::isInf(((NumberImp*)rep)->value());
+}