API/JSValueRef.cpp

   1 /*
   2  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "JSValueRef.h"
  28
  29 #include "APICast.h"
  30 #include "APIShims.h"
  31 #include "JSCallbackObject.h"
  32
  33 #include <runtime/JSGlobalObject.h>
  34 #include <runtime/JSONObject.h>
  35 #include <runtime/JSString.h>
  36 #include <runtime/LiteralParser.h>
  37 #include <runtime/Operations.h>
  38 #include <runtime/Protect.h>
  39 #include <runtime/UString.h>
  40 #include <runtime/JSValue.h>
  41
  42 #include <wtf/Assertions.h>
  43 #include <wtf/text/StringHash.h>
  44
  45 #include <algorithm> // for std::min
  46
  47 using namespace JSC;
  48
  49 ::JSType JSValueGetType(JSContextRef ctx, JSValueRef value)
  50 {
  51     ExecState* exec = toJS(ctx);
  52     APIEntryShim entryShim(exec);
  53
  54     JSValue jsValue = toJS(exec, value);
  55
  56     if (jsValue.isUndefined())
  57         return kJSTypeUndefined;
  58     if (jsValue.isNull())
  59         return kJSTypeNull;
  60     if (jsValue.isBoolean())
  61         return kJSTypeBoolean;
  62     if (jsValue.isNumber())
  63         return kJSTypeNumber;
  64     if (jsValue.isString())
  65         return kJSTypeString;
  66     ASSERT(jsValue.isObject());
  67     return kJSTypeObject;
  68 }
  69
  70 bool JSValueIsUndefined(JSContextRef ctx, JSValueRef value)
  71 {
  72     ExecState* exec = toJS(ctx);
  73     APIEntryShim entryShim(exec);
  74
  75     JSValue jsValue = toJS(exec, value);
  76     return jsValue.isUndefined();
  77 }
  78
  79 bool JSValueIsNull(JSContextRef ctx, JSValueRef value)
  80 {
  81     ExecState* exec = toJS(ctx);
  82     APIEntryShim entryShim(exec);
  83
  84     JSValue jsValue = toJS(exec, value);
  85     return jsValue.isNull();
  86 }
  87
  88 bool JSValueIsBoolean(JSContextRef ctx, JSValueRef value)
  89 {
  90     ExecState* exec = toJS(ctx);
  91     APIEntryShim entryShim(exec);
  92
  93     JSValue jsValue = toJS(exec, value);
  94     return jsValue.isBoolean();
  95 }
  96
  97 bool JSValueIsNumber(JSContextRef ctx, JSValueRef value)
  98 {
  99     ExecState* exec = toJS(ctx);
 100     APIEntryShim entryShim(exec);
 101
 102     JSValue jsValue = toJS(exec, value);
 103     return jsValue.isNumber();
 104 }
 105
 106 bool JSValueIsString(JSContextRef ctx, JSValueRef value)
 107 {
 108     ExecState* exec = toJS(ctx);
 109     APIEntryShim entryShim(exec);
 110
 111     JSValue jsValue = toJS(exec, value);
 112     return jsValue.isString();
 113 }
 114
 115 bool JSValueIsObject(JSContextRef ctx, JSValueRef value)
 116 {
 117     ExecState* exec = toJS(ctx);
 118     APIEntryShim entryShim(exec);
 119
 120     JSValue jsValue = toJS(exec, value);
 121     return jsValue.isObject();
 122 }
 123
 124 bool JSValueIsObjectOfClass(JSContextRef ctx, JSValueRef value, JSClassRef jsClass)
 125 {
 126     ExecState* exec = toJS(ctx);
 127     APIEntryShim entryShim(exec);
 128
 129     JSValue jsValue = toJS(exec, value);
 130
 131     if (JSObject* o = jsValue.getObject()) {
 132         if (o->inherits(&JSCallbackObject<JSGlobalObject>::s_info))
 133             return jsCast<JSCallbackObject<JSGlobalObject>*>(o)->inherits(jsClass);
 134         if (o->inherits(&JSCallbackObject<JSNonFinalObject>::s_info))
 135             return jsCast<JSCallbackObject<JSNonFinalObject>*>(o)->inherits(jsClass);
 136     }
 137     return false;
 138 }
 139
 140 bool JSValueIsEqual(JSContextRef ctx, JSValueRef a, JSValueRef b, JSValueRef* exception)
 141 {
 142     ExecState* exec = toJS(ctx);
 143     APIEntryShim entryShim(exec);
 144
 145     JSValue jsA = toJS(exec, a);
 146     JSValue jsB = toJS(exec, b);
 147
 148     bool result = JSValue::equal(exec, jsA, jsB); // false if an exception is thrown
 149     if (exec->hadException()) {
 150         if (exception)
 151             *exception = toRef(exec, exec->exception());
 152         exec->clearException();
 153     }
 154     return result;
 155 }
 156
 157 bool JSValueIsStrictEqual(JSContextRef ctx, JSValueRef a, JSValueRef b)
 158 {
 159     ExecState* exec = toJS(ctx);
 160     APIEntryShim entryShim(exec);
 161
 162     JSValue jsA = toJS(exec, a);
 163     JSValue jsB = toJS(exec, b);
 164
 165     return JSValue::strictEqual(exec, jsA, jsB);
 166 }
 167
 168 bool JSValueIsInstanceOfConstructor(JSContextRef ctx, JSValueRef value, JSObjectRef constructor, JSValueRef* exception)
 169 {
 170     ExecState* exec = toJS(ctx);
 171     APIEntryShim entryShim(exec);
 172
 173     JSValue jsValue = toJS(exec, value);
 174
 175     JSObject* jsConstructor = toJS(constructor);
 176     if (!jsConstructor->structure()->typeInfo().implementsHasInstance())
 177         return false;
 178     bool result = jsConstructor->methodTable()->hasInstance(jsConstructor, exec, jsValue, jsConstructor->get(exec, exec->propertyNames().prototype)); // false if an exception is thrown
 179     if (exec->hadException()) {
 180         if (exception)
 181             *exception = toRef(exec, exec->exception());
 182         exec->clearException();
 183     }
 184     return result;
 185 }
 186
 187 JSValueRef JSValueMakeUndefined(JSContextRef ctx)
 188 {
 189     ExecState* exec = toJS(ctx);
 190     APIEntryShim entryShim(exec);
 191
 192     return toRef(exec, jsUndefined());
 193 }
 194
 195 JSValueRef JSValueMakeNull(JSContextRef ctx)
 196 {
 197     ExecState* exec = toJS(ctx);
 198     APIEntryShim entryShim(exec);
 199
 200     return toRef(exec, jsNull());
 201 }
 202
 203 JSValueRef JSValueMakeBoolean(JSContextRef ctx, bool value)
 204 {
 205     ExecState* exec = toJS(ctx);
 206     APIEntryShim entryShim(exec);
 207
 208     return toRef(exec, jsBoolean(value));
 209 }
 210
 211 JSValueRef JSValueMakeNumber(JSContextRef ctx, double value)
 212 {
 213     ExecState* exec = toJS(ctx);
 214     APIEntryShim entryShim(exec);
 215
 216     // Our JSValue representation relies on a standard bit pattern for NaN. NaNs
 217     // generated internally to JavaScriptCore naturally have that representation,
 218     // but an external NaN might not.
 219     if (isnan(value))
 220         value = std::numeric_limits<double>::quiet_NaN();
 221
 222     return toRef(exec, jsNumber(value));
 223 }
 224
 225 JSValueRef JSValueMakeString(JSContextRef ctx, JSStringRef string)
 226 {
 227     ExecState* exec = toJS(ctx);
 228     APIEntryShim entryShim(exec);
 229
 230     return toRef(exec, jsString(exec, string->ustring()));
 231 }
 232
 233 JSValueRef JSValueMakeFromJSONString(JSContextRef ctx, JSStringRef string)
 234 {
 235     ExecState* exec = toJS(ctx);
 236     APIEntryShim entryShim(exec);
 237     UString str = string->ustring();
 238     if (str.is8Bit()) {
 239         LiteralParser<LChar> parser(exec, str.characters8(), str.length(), StrictJSON);
 240         return toRef(exec, parser.tryLiteralParse());
 241     }
 242     LiteralParser<UChar> parser(exec, str.characters16(), str.length(), StrictJSON);
 243     return toRef(exec, parser.tryLiteralParse());
 244 }
 245
 246 JSStringRef JSValueCreateJSONString(JSContextRef ctx, JSValueRef apiValue, unsigned indent, JSValueRef* exception)
 247 {
 248     ExecState* exec = toJS(ctx);
 249     APIEntryShim entryShim(exec);
 250     JSValue value = toJS(exec, apiValue);
 251     UString result = JSONStringify(exec, value, indent);
 252     if (exception)
 253         *exception = 0;
 254     if (exec->hadException()) {
 255         if (exception)
 256             *exception = toRef(exec, exec->exception());
 257         exec->clearException();
 258         return 0;
 259     }
 260     return OpaqueJSString::create(result).leakRef();
 261 }
 262
 263 bool JSValueToBoolean(JSContextRef ctx, JSValueRef value)
 264 {
 265     ExecState* exec = toJS(ctx);
 266     APIEntryShim entryShim(exec);
 267
 268     JSValue jsValue = toJS(exec, value);
 269     return jsValue.toBoolean(exec);
 270 }
 271
 272 double JSValueToNumber(JSContextRef ctx, JSValueRef value, JSValueRef* exception)
 273 {
 274     ExecState* exec = toJS(ctx);
 275     APIEntryShim entryShim(exec);
 276
 277     JSValue jsValue = toJS(exec, value);
 278
 279     double number = jsValue.toNumber(exec);
 280     if (exec->hadException()) {
 281         if (exception)
 282             *exception = toRef(exec, exec->exception());
 283         exec->clearException();
 284         number = std::numeric_limits<double>::quiet_NaN();
 285     }
 286     return number;
 287 }
 288
 289 JSStringRef JSValueToStringCopy(JSContextRef ctx, JSValueRef value, JSValueRef* exception)
 290 {
 291     ExecState* exec = toJS(ctx);
 292     APIEntryShim entryShim(exec);
 293
 294     JSValue jsValue = toJS(exec, value);
 295
 296     RefPtr<OpaqueJSString> stringRef(OpaqueJSString::create(jsValue.toString(exec)->value(exec)));
 297     if (exec->hadException()) {
 298         if (exception)
 299             *exception = toRef(exec, exec->exception());
 300         exec->clearException();
 301         stringRef.clear();
 302     }
 303     return stringRef.release().leakRef();
 304 }
 305
 306 JSObjectRef JSValueToObject(JSContextRef ctx, JSValueRef value, JSValueRef* exception)
 307 {
 308     ExecState* exec = toJS(ctx);
 309     APIEntryShim entryShim(exec);
 310
 311     JSValue jsValue = toJS(exec, value);
 312
 313     JSObjectRef objectRef = toRef(jsValue.toObject(exec));
 314     if (exec->hadException()) {
 315         if (exception)
 316             *exception = toRef(exec, exec->exception());
 317         exec->clearException();
 318         objectRef = 0;
 319     }
 320     return objectRef;
 321 }
 322
 323 void JSValueProtect(JSContextRef ctx, JSValueRef value)
 324 {
 325     ExecState* exec = toJS(ctx);
 326     APIEntryShim entryShim(exec);
 327
 328     JSValue jsValue = toJSForGC(exec, value);
 329     gcProtect(jsValue);
 330 }
 331
 332 void JSValueUnprotect(JSContextRef ctx, JSValueRef value)
 333 {
 334     ExecState* exec = toJS(ctx);
 335     APIEntryShim entryShim(exec);
 336
 337     JSValue jsValue = toJSForGC(exec, value);
 338     gcUnprotect(jsValue);
 339 }