summaryrefslogtreecommitdiffstats
path: root/kjs/value.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'kjs/value.cpp')
-rw-r--r--kjs/value.cpp412
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());
+}