Source/JavaScriptGlue/JSUtils.cpp

   1 /*
   2  * Copyright (C) 2005, 2008 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  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  14  *     its contributors may be used to endorse or promote products derived
  15  *     from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include "config.h"
  30 #include "JSUtils.h"
  31
  32 #include "JSBase.h"
  33 #include "JSObject.h"
  34 #include "JSRun.h"
  35 #include "JSValueWrapper.h"
  36 #include "UserObjectImp.h"
  37 #include <JavaScriptCore/JSString.h>
  38 #include <JavaScriptCore/PropertyNameArray.h>
  39 #include <JavaScriptCore/WTFThreadData.h>
  40
  41 struct ObjectImpList {
  42     JSObject* imp;
  43     ObjectImpList* next;
  44     CFTypeRef data;
  45 };
  46
  47 static CFTypeRef KJSValueToCFTypeInternal(JSValue inValue, ExecState *exec, ObjectImpList* inImps);
  48 static JSGlueGlobalObject* getThreadGlobalObject();
  49
  50 //--------------------------------------------------------------------------
  51 // CFStringToUString
  52 //--------------------------------------------------------------------------
  53
  54 UString CFStringToUString(CFStringRef inCFString)
  55 {
  56     UString result;
  57     if (inCFString) {
  58         CFIndex len = CFStringGetLength(inCFString);
  59         UniChar* buffer = (UniChar*)malloc(sizeof(UniChar) * len);
  60         if (buffer)
  61         {
  62             CFStringGetCharacters(inCFString, CFRangeMake(0, len), buffer);
  63             result = UString((const UChar *)buffer, len);
  64             free(buffer);
  65         }
  66     }
  67     return result;
  68 }
  69
  70
  71 //--------------------------------------------------------------------------
  72 // UStringToCFString
  73 //--------------------------------------------------------------------------
  74 // Caller is responsible for releasing the returned CFStringRef
  75 CFStringRef UStringToCFString(const UString& inUString)
  76 {
  77     return CFStringCreateWithCharacters(0, (const UniChar*)inUString.characters(), inUString.length());
  78 }
  79
  80
  81 //--------------------------------------------------------------------------
  82 // CFStringToIdentifier
  83 //--------------------------------------------------------------------------
  84
  85 Identifier CFStringToIdentifier(CFStringRef inCFString, ExecState* exec)
  86 {
  87     return Identifier(exec, CFStringToUString(inCFString));
  88 }
  89
  90
  91 //--------------------------------------------------------------------------
  92 // IdentifierToCFString
  93 //--------------------------------------------------------------------------
  94 // Caller is responsible for releasing the returned CFStringRef
  95 CFStringRef IdentifierToCFString(const Identifier& inIdentifier)
  96 {
  97     return UStringToCFString(inIdentifier.ustring());
  98 }
  99
 100
 101 //--------------------------------------------------------------------------
 102 // KJSValueToJSObject
 103 //--------------------------------------------------------------------------
 104 JSUserObject* KJSValueToJSObject(JSValue inValue, ExecState *exec)
 105 {
 106     JSUserObject* result = 0;
 107
 108     if (inValue.inherits(&UserObjectImp::s_info)) {
 109         UserObjectImp* userObjectImp = static_cast<UserObjectImp *>(asObject(inValue));
 110         result = userObjectImp->GetJSUserObject();
 111         if (result)
 112             result->Retain();
 113     } else {
 114         JSValueWrapper* wrapperValue = new JSValueWrapper(inValue);
 115         if (wrapperValue) {
 116             JSObjectCallBacks callBacks;
 117             JSValueWrapper::GetJSObectCallBacks(callBacks);
 118             result = (JSUserObject*)JSObjectCreate(wrapperValue, &callBacks);
 119             if (!result) {
 120                 delete wrapperValue;
 121             }
 122         }
 123     }
 124     return result;
 125 }
 126
 127 //--------------------------------------------------------------------------
 128 // JSObjectKJSValue
 129 //--------------------------------------------------------------------------
 130 JSValue JSObjectKJSValue(JSUserObject* ptr)
 131 {
 132     JSGlueAPIEntry entry;
 133
 134     JSValue result = jsUndefined();
 135     if (ptr)
 136     {
 137         bool handled = false;
 138
 139         switch (ptr->DataType())
 140         {
 141             case kJSUserObjectDataTypeJSValueWrapper:
 142             {
 143                 JSValueWrapper* wrapper = (JSValueWrapper*)ptr->GetData();
 144                 if (wrapper)
 145                 {
 146                     result = wrapper->GetValue();
 147                     handled = true;
 148                 }
 149                 break;
 150             }
 151
 152             case kJSUserObjectDataTypeCFType:
 153             {
 154                 CFTypeRef cfType = (CFTypeRef*)ptr->GetData();
 155                 if (cfType)
 156                 {
 157                     CFTypeID typeID = CFGetTypeID(cfType);
 158                     if (typeID == CFStringGetTypeID())
 159                     {
 160                         result = jsString(getThreadGlobalExecState(), CFStringToUString((CFStringRef)cfType));
 161                         handled = true;
 162                     }
 163                     else if (typeID == CFNumberGetTypeID())
 164                     {
 165                         double num;
 166                         CFNumberGetValue((CFNumberRef)cfType, kCFNumberDoubleType, &num);
 167                         result = jsNumber(num);
 168                         handled = true;
 169                     }
 170                     else if (typeID == CFBooleanGetTypeID())
 171                     {
 172                         result = jsBoolean(CFBooleanGetValue((CFBooleanRef)cfType));
 173                         handled = true;
 174                     }
 175                     else if (typeID == CFNullGetTypeID())
 176                     {
 177                         result = jsNull();
 178                         handled = true;
 179                     }
 180                 }
 181                 break;
 182             }
 183         }
 184         if (!handled)
 185         {
 186             ExecState* exec = getThreadGlobalExecState();
 187             result = new (exec) UserObjectImp(exec->globalData(), getThreadGlobalObject()->userObjectStructure(), ptr);
 188         }
 189     }
 190     return result;
 191 }
 192
 193
 194
 195
 196 //--------------------------------------------------------------------------
 197 // KJSValueToCFTypeInternal
 198 //--------------------------------------------------------------------------
 199 // Caller is responsible for releasing the returned CFTypeRef
 200 CFTypeRef KJSValueToCFTypeInternal(JSValue inValue, ExecState *exec, ObjectImpList* inImps)
 201 {
 202     if (!inValue)
 203         return 0;
 204
 205     CFTypeRef result = 0;
 206
 207     JSGlueAPIEntry entry;
 208
 209         if (inValue.isBoolean())
 210             {
 211                 result = inValue.toBoolean(exec) ? kCFBooleanTrue : kCFBooleanFalse;
 212                 RetainCFType(result);
 213                 return result;
 214             }
 215
 216         if (inValue.isString())
 217             {
 218                 UString uString = inValue.toString(exec);
 219                 result = UStringToCFString(uString);
 220                 return result;
 221             }
 222
 223         if (inValue.isNumber())
 224             {
 225                 double number1 = inValue.toNumber(exec);
 226                 double number2 = (double)inValue.toInteger(exec);
 227                 if (number1 ==  number2)
 228                 {
 229                     int intValue = (int)number2;
 230                     result = CFNumberCreate(0, kCFNumberIntType, &intValue);
 231                 }
 232                 else
 233                 {
 234                     result = CFNumberCreate(0, kCFNumberDoubleType, &number1);
 235                 }
 236                 return result;
 237             }
 238
 239         if (inValue.isObject())
 240             {
 241                 if (inValue.inherits(&UserObjectImp::s_info)) {
 242                     UserObjectImp* userObjectImp = static_cast<UserObjectImp *>(asObject(inValue));
 243                     JSUserObject* ptr = userObjectImp->GetJSUserObject();
 244                     if (ptr)
 245                     {
 246                         result = ptr->CopyCFValue();
 247                     }
 248                 }
 249                 else
 250                 {
 251                     JSObject *object = inValue.toObject(exec);
 252                     UInt8 isArray = false;
 253
 254                     // if two objects reference each
 255                     JSObject* imp = object;
 256                     ObjectImpList* temp = inImps;
 257                     while (temp) {
 258                         if (imp == temp->imp) {
 259                             return CFRetain(GetCFNull());
 260                         }
 261                         temp = temp->next;
 262                     }
 263
 264                     ObjectImpList imps;
 265                     imps.next = inImps;
 266                     imps.imp = imp;
 267
 268
 269 //[...] HACK since we do not have access to the class info we use class name instead
 270 #if 0
 271                     if (object->inherits(&ArrayInstanceImp::s_info))
 272 #else
 273                     if (object->className() == "Array")
 274 #endif
 275                     {
 276                         isArray = true;
 277                         JSGlueGlobalObject* globalObject = static_cast<JSGlueGlobalObject*>(exec->dynamicGlobalObject());
 278                         if (globalObject && (globalObject->Flags() & kJSFlagConvertAssociativeArray)) {
 279                             PropertyNameArray propNames(exec);
 280                             object->getPropertyNames(exec, propNames);
 281                             PropertyNameArray::const_iterator iter = propNames.begin();
 282                             PropertyNameArray::const_iterator end = propNames.end();
 283                             while(iter != end && isArray)
 284                             {
 285                                 Identifier propName = *iter;
 286                                 UString ustr = propName.ustring();
 287                                 const UniChar* uniChars = (const UniChar*)ustr.characters();
 288                                 int size = ustr.length();
 289                                 while (size--) {
 290                                     if (uniChars[size] < '0' || uniChars[size] > '9') {
 291                                         isArray = false;
 292                                         break;
 293                                     }
 294                                 }
 295                                 iter++;
 296                             }
 297                         }
 298                     }
 299
 300                     if (isArray)
 301                     {
 302                         // This is an KJS array
 303                         unsigned int length = object->get(exec, Identifier(exec, "length")).toUInt32(exec);
 304                         result = CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks);
 305                         if (result)
 306                         {
 307                             for (unsigned i = 0; i < length; i++)
 308                             {
 309                                 CFTypeRef cfValue = KJSValueToCFTypeInternal(object->get(exec, i), exec, &imps);
 310                                 CFArrayAppendValue((CFMutableArrayRef)result, cfValue);
 311                                 ReleaseCFType(cfValue);
 312                             }
 313                         }
 314                     }
 315                     else
 316                     {
 317                         // Not an array, just treat it like a dictionary which contains (property name, property value) pairs
 318                         PropertyNameArray propNames(exec);
 319                         object->getPropertyNames(exec, propNames);
 320                         {
 321                             result = CFDictionaryCreateMutable(0,
 322                                                                0,
 323                                                                &kCFTypeDictionaryKeyCallBacks,
 324                                                                &kCFTypeDictionaryValueCallBacks);
 325                             if (result)
 326                             {
 327                                 PropertyNameArray::const_iterator iter = propNames.begin();
 328                                 PropertyNameArray::const_iterator end = propNames.end();
 329                                 while(iter != end)
 330                                 {
 331                                     Identifier propName = *iter;
 332                                     if (object->hasProperty(exec, propName))
 333                                     {
 334                                         CFStringRef cfKey = IdentifierToCFString(propName);
 335                                         CFTypeRef cfValue = KJSValueToCFTypeInternal(object->get(exec, propName), exec, &imps);
 336                                         if (cfKey && cfValue)
 337                                         {
 338                                             CFDictionaryAddValue((CFMutableDictionaryRef)result, cfKey, cfValue);
 339                                         }
 340                                         ReleaseCFType(cfKey);
 341                                         ReleaseCFType(cfValue);
 342                                     }
 343                                     iter++;
 344                                 }
 345                             }
 346                         }
 347                     }
 348                 }
 349                 return result;
 350             }
 351
 352     if (inValue.isUndefinedOrNull())
 353         {
 354             result = RetainCFType(GetCFNull());
 355             return result;
 356         }
 357
 358     ASSERT_NOT_REACHED();
 359     return 0;
 360 }
 361
 362 CFTypeRef KJSValueToCFType(JSValue inValue, ExecState *exec)
 363 {
 364     return KJSValueToCFTypeInternal(inValue, exec, 0);
 365 }
 366
 367 CFTypeRef GetCFNull(void)
 368 {
 369     static CFArrayRef sCFNull = CFArrayCreate(0, 0, 0, 0);
 370     CFTypeRef result = JSGetCFNull();
 371     if (!result)
 372     {
 373         result = sCFNull;
 374     }
 375     return result;
 376 }
 377
 378 /*
 379  * This is a slight hack. The JSGlue API has no concept of execution state.
 380  * However, execution state is an inherent part of JS, and JSCore requires it.
 381  * So, we keep a single execution state for the whole thread and supply it
 382  * where necessary.
 383
 384  * The execution state holds two things: (1) exceptions; (2) the global object.
 385  * JSGlue has no API for accessing exceptions, so we just discard them. As for
 386  * the global object, JSGlue includes no calls that depend on it. Its property
 387  * getters and setters are per-object; they don't walk up the enclosing scope.
 388  * Functions called by JSObjectCallFunction may reference values in the enclosing
 389  * scope, but they do so through an internally stored scope chain, so we don't
 390  * need to supply the global scope.
 391  */
 392
 393 static pthread_key_t globalObjectKey;
 394 static pthread_once_t globalObjectKeyOnce = PTHREAD_ONCE_INIT;
 395
 396 static void unprotectGlobalObject(void* data)
 397 {
 398     JSGlueAPIEntry entry;
 399     gcUnprotect(static_cast<JSGlueGlobalObject*>(data));
 400 }
 401
 402 static void initializeGlobalObjectKey()
 403 {
 404     pthread_key_create(&globalObjectKey, unprotectGlobalObject);
 405 }
 406
 407 JSGlobalData* getThreadGlobalData()
 408 {
 409     return &JSGlobalData::sharedInstance();
 410 }
 411
 412 static JSGlueGlobalObject* getThreadGlobalObject()
 413 {
 414     pthread_once(&globalObjectKeyOnce, initializeGlobalObjectKey);
 415     JSGlueGlobalObject* globalObject = static_cast<JSGlueGlobalObject*>(pthread_getspecific(globalObjectKey));
 416     if (!globalObject) {
 417         globalObject = new (getThreadGlobalData()) JSGlueGlobalObject(*getThreadGlobalData(), JSGlueGlobalObject::createStructure(*getThreadGlobalData(), jsNull()));
 418         gcProtect(globalObject);
 419         pthread_setspecific(globalObjectKey, globalObject);
 420     }
 421     return globalObject;
 422 }
 423
 424 ExecState* getThreadGlobalExecState()
 425 {
 426     ExecState* exec = getThreadGlobalObject()->globalExec();
 427
 428     // Discard exceptions -- otherwise an exception would forestall JS
 429     // evaluation throughout the thread
 430     exec->clearException();
 431     return exec;
 432 }
 433
 434 JSGlueAPIEntry::JSGlueAPIEntry()
 435     : m_lock(LockForReal)
 436     , m_storedIdentifierTable(wtfThreadData().currentIdentifierTable())
 437 {
 438     wtfThreadData().setCurrentIdentifierTable(getThreadGlobalData()->identifierTable);
 439 }
 440
 441 JSGlueAPIEntry::~JSGlueAPIEntry()
 442 {
 443     wtfThreadData().setCurrentIdentifierTable(m_storedIdentifierTable);
 444 }
 445
 446 JSGlueAPICallback::JSGlueAPICallback(ExecState* exec)
 447     : m_dropLocks(exec)
 448 {
 449     wtfThreadData().resetCurrentIdentifierTable();
 450 }
 451
 452 JSGlueAPICallback::~JSGlueAPICallback()
 453 {
 454     wtfThreadData().setCurrentIdentifierTable(getThreadGlobalData()->identifierTable);
 455 }