File indexing completed on 2024-05-12 15:43:23

 /*
  *  This file is part of the KDE libraries
  *  Copyright (C) 1999-2002 Harri Porten (porten@kde.org)
  *  Copyright (C) 2001 Peter Kelly (pmk@post.com)
  *  Copyright (C) 2004 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 "internal.h"
 
 #include "array_object.h"
 #include "bool_object.h"
 #include "collector.h"
 #include "date_object.h"
 #include "debugger.h"
 #include "error_object.h"
 #include "function_object.h"
 #include "lexer.h"
 #include "math_object.h"
 #include "nodes.h"
 #include "number_object.h"
 #include "object_object.h"
 #include "operations.h"
 #include "regexp_object.h"
 #include "string_object.h"
 #include <assert.h>
 #include <wtf/HashMap.h>
 #include <wtf/HashSet.h>
 #include <wtf/Vector.h>
 #include <math.h>
 #include <stdio.h>
 
 namespace KJS
 {
 
 #if defined(WTF_COMPILER_MSVC)
 #define copysign _copysign
 #endif
 
 static const double D16 = 65536.0;
 static const double D32 = 4294967296.0;
 
 // ------------------------------ StringImp ------------------------------------
 
 JSValue *StringImp::toPrimitive(ExecState *, JSType) const
 {
     return const_cast<StringImp *>(this);
 }
 
 bool GetterSetterImp::getPrimitiveNumber(ExecState *, double &number, JSValue *&value)
 {
     ASSERT_NOT_REACHED();
     number = 0;
     value = nullptr;
     return true;
 }
 
 bool StringImp::getPrimitiveNumber(ExecState *, double &number, JSValue *&value)
 {
     value = this;
     number = val.toDouble();
     return false;
 }
 
 bool StringImp::toBoolean(ExecState *) const
 {
     return (val.size() > 0);
 }
 
 double StringImp::toNumber(ExecState *) const
 {
     return val.toDouble();
 }
 
 UString StringImp::toString(ExecState *) const
 {
     return val;
 }
 
 JSObject *StringImp::toObject(ExecState *exec) const
 {
     return new StringInstance(exec->lexicalInterpreter()->builtinStringPrototype(), const_cast<StringImp *>(this));
 }
 
 // ------------------------------ NumberImp ------------------------------------
 
 JSValue *NumberImp::toPrimitive(ExecState *, JSType) const
 {
     return const_cast<NumberImp *>(this);
 }
 
 bool NumberImp::getPrimitiveNumber(ExecState *, double &number, JSValue *&value)
 {
     number = val;
     value = this;
     return true;
 }
 
 bool NumberImp::toBoolean(ExecState *) const
 {
     return val < 0.0 || val > 0.0; // false for NaN
 }
 
 double NumberImp::toNumber(ExecState *) const
 {
     return val;
 }
 
 UString NumberImp::toString(ExecState *) const
 {
     if (val == 0.0) { // +0.0 or -0.0
         return "0";
     }
     return UString::from(val);
 }
 
 JSObject *NumberImp::toObject(ExecState *exec) const
 {
     List args;
     args.append(const_cast<NumberImp *>(this));
     return static_cast<JSObject *>(exec->lexicalInterpreter()->builtinNumber()->construct(exec, args));
 }
 
 bool NumberImp::getUInt32(uint32_t &uint32) const
 {
     uint32 = static_cast<uint32_t>(val);
     return uint32 == val;
 }
 
 bool NumberImp::getTruncatedInt32(int32_t &int32) const
 {
     if (!(val >= -2147483648.0 && val < 2147483648.0)) {
         return false;
     }
     int32 = static_cast<int32_t>(val);
     return true;
 }
 
 bool NumberImp::getTruncatedUInt32(uint32_t &uint32) const
 {
     if (!(val >= 0.0 && val < 4294967296.0)) {
         return false;
     }
     uint32 = static_cast<uint32_t>(val);
     return true;
 }
 
 // --------------------------- GetterSetterImp ---------------------------------
 void GetterSetterImp::mark()
 {
     JSCell::mark();
 
     if (getter && !getter->marked()) {
         getter->mark();
     }
     if (setter && !setter->marked()) {
         setter->mark();
     }
 }
 
 JSValue *GetterSetterImp::toPrimitive(ExecState *, JSType) const
 {
     assert(false);
     return jsNull();
 }
 
 bool GetterSetterImp::toBoolean(ExecState *) const
 {
     assert(false);
     return false;
 }
 
 double GetterSetterImp::toNumber(ExecState *) const
 {
     assert(false);
     return 0.0;
 }
 
 UString GetterSetterImp::toString(ExecState *) const
 {
     assert(false);
     return UString::null();
 }
 
 JSObject *GetterSetterImp::toObject(ExecState *exec) const
 {
     assert(false);
     return JSValue::toObject(jsNull(), exec);
 }
 
 // ------------------------------ InternalFunctionImp --------------------------
 
 const ClassInfo InternalFunctionImp::info = {"Function", nullptr, nullptr, nullptr};
 
 InternalFunctionImp::InternalFunctionImp()
 {
 }
 
 InternalFunctionImp::InternalFunctionImp(FunctionPrototype *funcProto)
     : JSObject(funcProto)
 {
 }
 
 InternalFunctionImp::InternalFunctionImp(FunctionPrototype *funcProto, const Identifier &name)
     : JSObject(funcProto)
     , m_name(name)
 {
 }
 
 bool InternalFunctionImp::implementsCall() const
 {
     return true;
 }
 
 bool InternalFunctionImp::implementsHasInstance() const
 {
     return true;
 }
 
 // ------------------------------ global functions -----------------------------
 
 double roundValue(double d)
 {
     double ad = fabs(d);
     if (ad == 0 || isNaN(d) || isInf(d)) {
         return d;
     }
     return copysign(floor(ad), d);
 }
 
 int32_t toInt32(double d)
 {
     if (isNaN(d) || isInf(d)) {
         return 0;
     }
     double d32 = fmod(roundValue(d), D32);
 
     if (d32 >= D32 / 2) {
         d32 -= D32;
     } else if (d32 < -D32 / 2) {
         d32 += D32;
     }
 
     return static_cast<int32_t>(d32);
 }
 
 int32_t toInt32(double d, bool &ok)
 {
     ok = true;
     if (isNaN(d) || isInf(d)) {
         ok = false;
         return 0;
     }
     return toInt32(d);
 }
 
 uint32_t toUInt32(double dd)
 {
     double d = roundValue(dd);
     if (isNaN(d) || isInf(d)) {
         return 0;
     }
     double d32 = fmod(d, D32);
 
     if (d32 < 0) {
         d32 += D32;
     }
 
     return static_cast<uint32_t>(d32);
 }
 
 uint16_t toUInt16(double dd)
 {
     double d = roundValue(dd);
     if (isNaN(d) || isInf(d)) {
         return 0;
     }
     double d16 = fmod(d, D16);
 
     if (d16 < 0) {
         d16 += D16;
     }
 
     return static_cast<uint16_t>(d16);
 }
 
 //#ifndef NDEBUG
 void printInfo(ExecState *exec, const char *s, JSValue *o, int lineno)
 {
     UString vString;
     if (!o) {
         fprintf(stderr, "KJS: %s: (null)", s);
     } else {
         JSValue *v = o;
 
         unsigned int arrayLength = 0;
         bool hadExcep = exec->hadException();
 
         UString name;
         switch (JSValue::type(v)) {
         case UnspecifiedType:
             name = "Unspecified";
             break;
         case UndefinedType:
             name = "Undefined";
             break;
         case NullType:
             name = "Null";
             break;
         case BooleanType:
             name = "Boolean";
             break;
         case StringType:
             name = "String";
             break;
         case NumberType:
             name = "Number";
             break;
         case ObjectType: {
             JSObject *obj = static_cast<JSObject *>(v);
             name = obj->className();
             if (name.isNull()) {
                 name = "(unknown class)";
             }
 
             if (obj->inherits(&ArrayInstance::info)) {
                 arrayLength = JSValue::toUInt32(obj->get(exec, exec->propertyNames().length), exec);
             }
             vString = "[object " + name + "]"; // krazy:exclude=doublequote_chars
             break;
         }
         case GetterSetterType:
             name = "GetterSetter";
             break;
         }
 
         // Avoid calling toString on a huge array (e.g. 4 billion elements, in mozilla/js/js1_5/Array/array-001.js)
         if (arrayLength > 100) {
             vString = UString("[ Array with ") + UString::from(arrayLength) + " elements ]";
         } else if (JSValue::type(v) != ObjectType) { // Don't want to call a user toString function!
             vString = JSValue::toString(v, exec);
         }
         if (!hadExcep) {
             exec->clearException();
         }
 
         if (vString.size() > 350) {
             vString = vString.substr(0, 350) + "...";
         }
 
         // Can't use two UString::ascii() in the same fprintf call
         CString tempString(vString.cstring());
 
         fprintf(stderr, "KJS: %s: %s : %s (%p)",
                 s, tempString.c_str(), name.ascii(), (void *)v);
 
         if (lineno >= 0) {
             fprintf(stderr, ", line %d\n", lineno);
         } else {
             fprintf(stderr, "\n");
         }
     }
 }
 //#endif
 
 }