js/jsd/jsd_val.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 /*
  39  * JavaScript Debugging support - Value and Property support
  40  */
  41
  42 #include "jsd.h"
  43 #include "jsapi.h"
  44 #include "jspubtd.h"
  45
  46 /*
  47  * Lifted with slight modification from jsobj.h
  48  */
  49
  50 #define OBJ_TO_OUTER_OBJECT(cx, obj)                                \
  51 do {                                                                \
  52     JSClass *clasp_ = JS_GetClass(cx, obj);                         \
  53     if (clasp_->flags & JSCLASS_IS_EXTENDED) {                      \
  54         JSExtendedClass *xclasp_ = (JSExtendedClass*) clasp_;       \
  55         if (xclasp_->outerObject)                                   \
  56             obj = xclasp_->outerObject(cx, obj);                    \
  57     }                                                               \
  58 } while(0)
  59
  60 #ifdef DEBUG
  61 void JSD_ASSERT_VALID_VALUE(JSDValue* jsdval)
  62 {
  63     JS_ASSERT(jsdval);
  64     JS_ASSERT(jsdval->nref > 0);
  65     if(!JS_CLIST_IS_EMPTY(&jsdval->props))
  66     {
  67         JS_ASSERT(CHECK_BIT_FLAG(jsdval->flags, GOT_PROPS));
  68         JS_ASSERT(JSVAL_IS_OBJECT(jsdval->val));
  69     }
  70
  71     if(jsdval->proto)
  72     {
  73         JS_ASSERT(CHECK_BIT_FLAG(jsdval->flags, GOT_PROTO));
  74         JS_ASSERT(jsdval->proto->nref > 0);
  75     }
  76     if(jsdval->parent)
  77     {
  78         JS_ASSERT(CHECK_BIT_FLAG(jsdval->flags, GOT_PARENT));
  79         JS_ASSERT(jsdval->parent->nref > 0);
  80     }
  81     if(jsdval->ctor)
  82     {
  83         JS_ASSERT(CHECK_BIT_FLAG(jsdval->flags, GOT_CTOR));
  84         JS_ASSERT(jsdval->ctor->nref > 0);
  85     }
  86 }
  87
  88 void JSD_ASSERT_VALID_PROPERTY(JSDProperty* jsdprop)
  89 {
  90     JS_ASSERT(jsdprop);
  91     JS_ASSERT(jsdprop->name);
  92     JS_ASSERT(jsdprop->name->nref > 0);
  93     JS_ASSERT(jsdprop->val);
  94     JS_ASSERT(jsdprop->val->nref > 0);
  95     if(jsdprop->alias)
  96         JS_ASSERT(jsdprop->alias->nref > 0);
  97 }
  98 #endif
  99
 100
 101 JSBool
 102 jsd_IsValueObject(JSDContext* jsdc, JSDValue* jsdval)
 103 {
 104     return JSVAL_IS_OBJECT(jsdval->val);
 105 }
 106
 107 JSBool
 108 jsd_IsValueNumber(JSDContext* jsdc, JSDValue* jsdval)
 109 {
 110     return JSVAL_IS_NUMBER(jsdval->val);
 111 }
 112
 113 JSBool
 114 jsd_IsValueInt(JSDContext* jsdc, JSDValue* jsdval)
 115 {
 116     return JSVAL_IS_INT(jsdval->val);
 117 }
 118
 119 JSBool
 120 jsd_IsValueDouble(JSDContext* jsdc, JSDValue* jsdval)
 121 {
 122     return JSVAL_IS_DOUBLE(jsdval->val);
 123 }
 124
 125 JSBool
 126 jsd_IsValueString(JSDContext* jsdc, JSDValue* jsdval)
 127 {
 128     return JSVAL_IS_STRING(jsdval->val);
 129 }
 130
 131 JSBool
 132 jsd_IsValueBoolean(JSDContext* jsdc, JSDValue* jsdval)
 133 {
 134     return JSVAL_IS_BOOLEAN(jsdval->val);
 135 }
 136
 137 JSBool
 138 jsd_IsValueNull(JSDContext* jsdc, JSDValue* jsdval)
 139 {
 140     return JSVAL_IS_NULL(jsdval->val);
 141 }
 142
 143 JSBool
 144 jsd_IsValueVoid(JSDContext* jsdc, JSDValue* jsdval)
 145 {
 146     return JSVAL_IS_VOID(jsdval->val);
 147 }
 148
 149 JSBool
 150 jsd_IsValuePrimitive(JSDContext* jsdc, JSDValue* jsdval)
 151 {
 152     return JSVAL_IS_PRIMITIVE(jsdval->val);
 153 }
 154
 155 JSBool
 156 jsd_IsValueFunction(JSDContext* jsdc, JSDValue* jsdval)
 157 {
 158     return !JSVAL_IS_PRIMITIVE(jsdval->val) &&
 159            JS_ObjectIsFunction(jsdc->dumbContext, JSVAL_TO_OBJECT(jsdval->val));
 160 }
 161
 162 JSBool
 163 jsd_IsValueNative(JSDContext* jsdc, JSDValue* jsdval)
 164 {
 165     JSContext* cx = jsdc->dumbContext;
 166     jsval val = jsdval->val;
 167     JSFunction* fun;
 168     JSExceptionState* exceptionState;
 169
 170     if(jsd_IsValueFunction(jsdc, jsdval))
 171     {
 172         JSBool ok = JS_FALSE;
 173         JS_BeginRequest(cx);
 174         exceptionState = JS_SaveExceptionState(cx);
 175         fun = JS_ValueToFunction(cx, val);
 176         JS_RestoreExceptionState(cx, exceptionState);
 177         if(fun)
 178             ok = JS_GetFunctionScript(cx, fun) ? JS_FALSE : JS_TRUE;
 179         JS_EndRequest(cx);
 180         JS_ASSERT(fun);
 181         return ok;
 182     }
 183     return !JSVAL_IS_PRIMITIVE(val);
 184 }
 185
 186 /***************************************************************************/
 187
 188 JSBool
 189 jsd_GetValueBoolean(JSDContext* jsdc, JSDValue* jsdval)
 190 {
 191     jsval val = jsdval->val;
 192     if(!JSVAL_IS_BOOLEAN(val))
 193         return JS_FALSE;
 194     return JSVAL_TO_BOOLEAN(val);
 195 }
 196
 197 int32
 198 jsd_GetValueInt(JSDContext* jsdc, JSDValue* jsdval)
 199 {
 200     jsval val = jsdval->val;
 201     if(!JSVAL_IS_INT(val))
 202         return 0;
 203     return JSVAL_TO_INT(val);
 204 }
 205
 206 jsdouble*
 207 jsd_GetValueDouble(JSDContext* jsdc, JSDValue* jsdval)
 208 {
 209     jsval val = jsdval->val;
 210     if(!JSVAL_IS_DOUBLE(val))
 211         return 0;
 212     return JSVAL_TO_DOUBLE(val);
 213 }
 214
 215 JSString*
 216 jsd_GetValueString(JSDContext* jsdc, JSDValue* jsdval)
 217 {
 218     JSContext* cx = jsdc->dumbContext;
 219     JSExceptionState* exceptionState;
 220
 221     if(!jsdval->string)
 222     {
 223         /* if the jsval is a string, then we don't need to double root it */
 224         if(JSVAL_IS_STRING(jsdval->val))
 225             jsdval->string = JSVAL_TO_STRING(jsdval->val);
 226         else
 227         {
 228             JS_BeginRequest(cx);
 229             exceptionState = JS_SaveExceptionState(cx);
 230             jsdval->string = JS_ValueToString(cx, jsdval->val);
 231             JS_RestoreExceptionState(cx, exceptionState);
 232             if(jsdval->string)
 233             {
 234                 if(!JS_AddNamedRoot(cx, &jsdval->string, "ValueString"))
 235                     jsdval->string = NULL;
 236             }
 237             JS_EndRequest(cx);
 238         }
 239     }
 240     return jsdval->string;
 241 }
 242
 243 const char*
 244 jsd_GetValueFunctionName(JSDContext* jsdc, JSDValue* jsdval)
 245 {
 246     JSContext* cx = jsdc->dumbContext;
 247     JSFunction* fun;
 248     JSExceptionState* exceptionState;
 249
 250     if(!jsdval->funName && jsd_IsValueFunction(jsdc, jsdval))
 251     {
 252         JS_BeginRequest(cx);
 253         exceptionState = JS_SaveExceptionState(cx);
 254         fun = JS_ValueToFunction(cx, jsdval->val);
 255         JS_RestoreExceptionState(cx, exceptionState);
 256         JS_EndRequest(cx);
 257         if(!fun)
 258             return NULL;
 259         jsdval->funName = JS_GetFunctionName(fun);
 260     }
 261     return jsdval->funName;
 262 }
 263
 264 /***************************************************************************/
 265
 266 JSDValue*
 267 jsd_NewValue(JSDContext* jsdc, jsval val)
 268 {
 269     JSDValue* jsdval;
 270
 271     if(!(jsdval = (JSDValue*) calloc(1, sizeof(JSDValue))))
 272         return NULL;
 273
 274     if(JSVAL_IS_GCTHING(val))
 275     {
 276         JSBool ok = JS_FALSE;
 277         JS_BeginRequest(jsdc->dumbContext);
 278         ok = JS_AddNamedRoot(jsdc->dumbContext, &jsdval->val, "JSDValue");
 279         JS_EndRequest(jsdc->dumbContext);
 280         if(!ok)
 281         {
 282             free(jsdval);
 283             return NULL;
 284         }
 285     }
 286     jsdval->val  = val;
 287     jsdval->nref = 1;
 288     JS_INIT_CLIST(&jsdval->props);
 289
 290     return jsdval;
 291 }
 292
 293 void
 294 jsd_DropValue(JSDContext* jsdc, JSDValue* jsdval)
 295 {
 296     JS_ASSERT(jsdval->nref > 0);
 297     if(0 == --jsdval->nref)
 298     {
 299         jsd_RefreshValue(jsdc, jsdval);
 300         if(JSVAL_IS_GCTHING(jsdval->val))
 301         {
 302             JS_BeginRequest(jsdc->dumbContext);
 303             JS_RemoveRoot(jsdc->dumbContext, &jsdval->val);
 304             JS_EndRequest(jsdc->dumbContext);
 305         }
 306         free(jsdval);
 307     }
 308 }
 309
 310 jsval
 311 jsd_GetValueWrappedJSVal(JSDContext* jsdc, JSDValue* jsdval)
 312 {
 313     JSObject* obj;
 314     JSContext* cx;
 315     jsval val = jsdval->val;
 316     if (!JSVAL_IS_PRIMITIVE(val)) {
 317         cx = JSD_GetDefaultJSContext(jsdc);
 318         obj = JSVAL_TO_OBJECT(val);
 319         OBJ_TO_OUTER_OBJECT(cx, obj);
 320         if (!obj)
 321         {
 322             JS_ClearPendingException(cx);
 323             val = JSVAL_NULL;
 324         }
 325         else
 326             val = OBJECT_TO_JSVAL(obj);
 327     }
 328
 329     return val;
 330 }
 331
 332 static JSDProperty* _newProperty(JSDContext* jsdc, JSPropertyDesc* pd,
 333                                  uintN additionalFlags)
 334 {
 335     JSDProperty* jsdprop;
 336
 337     if(!(jsdprop = (JSDProperty*) calloc(1, sizeof(JSDProperty))))
 338         return NULL;
 339
 340     JS_INIT_CLIST(&jsdprop->links);
 341     jsdprop->nref = 1;
 342     jsdprop->flags = pd->flags | additionalFlags;
 343     jsdprop->slot = pd->slot;
 344
 345     if(!(jsdprop->name = jsd_NewValue(jsdc, pd->id)))
 346         goto new_prop_fail;
 347
 348     if(!(jsdprop->val = jsd_NewValue(jsdc, pd->value)))
 349         goto new_prop_fail;
 350
 351     if((jsdprop->flags & JSDPD_ALIAS) &&
 352        !(jsdprop->alias = jsd_NewValue(jsdc, pd->alias)))
 353         goto new_prop_fail;
 354
 355     return jsdprop;
 356 new_prop_fail:
 357     jsd_DropProperty(jsdc, jsdprop);
 358     return NULL;
 359 }
 360
 361 static void _freeProps(JSDContext* jsdc, JSDValue* jsdval)
 362 {
 363     JSDProperty* jsdprop;
 364
 365     while(jsdprop = (JSDProperty*)jsdval->props.next,
 366           jsdprop != (JSDProperty*)&jsdval->props)
 367     {
 368         JS_REMOVE_AND_INIT_LINK(&jsdprop->links);
 369         jsd_DropProperty(jsdc, jsdprop);
 370     }
 371     JS_ASSERT(JS_CLIST_IS_EMPTY(&jsdval->props));
 372     CLEAR_BIT_FLAG(jsdval->flags, GOT_PROPS);
 373 }
 374
 375 static JSBool _buildProps(JSDContext* jsdc, JSDValue* jsdval)
 376 {
 377     JSContext* cx = jsdc->dumbContext;
 378     JSPropertyDescArray pda;
 379     uintN i;
 380
 381     JS_ASSERT(JS_CLIST_IS_EMPTY(&jsdval->props));
 382     JS_ASSERT(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PROPS)));
 383     JS_ASSERT(JSVAL_IS_OBJECT(jsdval->val));
 384
 385     if(!JSVAL_IS_OBJECT(jsdval->val) || JSVAL_IS_NULL(jsdval->val))
 386         return JS_FALSE;
 387
 388     JS_BeginRequest(cx);
 389     if(!JS_GetPropertyDescArray(cx, JSVAL_TO_OBJECT(jsdval->val), &pda))
 390     {
 391         JS_EndRequest(cx);
 392         return JS_FALSE;
 393     }
 394
 395     for(i = 0; i < pda.length; i++)
 396     {
 397         JSDProperty* prop = _newProperty(jsdc, &pda.array[i], 0);
 398         if(!prop)
 399         {
 400             _freeProps(jsdc, jsdval);
 401             break;
 402         }
 403         JS_APPEND_LINK(&prop->links, &jsdval->props);
 404     }
 405     JS_PutPropertyDescArray(cx, &pda);
 406     JS_EndRequest(cx);
 407     SET_BIT_FLAG(jsdval->flags, GOT_PROPS);
 408     return !JS_CLIST_IS_EMPTY(&jsdval->props);
 409 }
 410
 411 #undef  DROP_CLEAR_VALUE
 412 #define DROP_CLEAR_VALUE(jsdc, x) if(x){jsd_DropValue(jsdc,x); x = NULL;}
 413
 414 void
 415 jsd_RefreshValue(JSDContext* jsdc, JSDValue* jsdval)
 416 {
 417     JSContext* cx = jsdc->dumbContext;
 418
 419     if(jsdval->string)
 420     {
 421         /* if the jsval is a string, then we didn't need to root the string */
 422         if(!JSVAL_IS_STRING(jsdval->val))
 423         {
 424             JS_BeginRequest(cx);
 425             JS_RemoveRoot(cx, &jsdval->string);
 426             JS_EndRequest(cx);
 427         }
 428         jsdval->string = NULL;
 429     }
 430
 431     jsdval->funName = NULL;
 432     jsdval->className = NULL;
 433     DROP_CLEAR_VALUE(jsdc, jsdval->proto);
 434     DROP_CLEAR_VALUE(jsdc, jsdval->parent);
 435     DROP_CLEAR_VALUE(jsdc, jsdval->ctor);
 436     _freeProps(jsdc, jsdval);
 437     jsdval->flags = 0;
 438 }
 439
 440 /***************************************************************************/
 441
 442 uintN
 443 jsd_GetCountOfProperties(JSDContext* jsdc, JSDValue* jsdval)
 444 {
 445     JSDProperty* jsdprop;
 446     uintN count = 0;
 447
 448     if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PROPS)))
 449         if(!_buildProps(jsdc, jsdval))
 450             return 0;
 451
 452     for(jsdprop = (JSDProperty*)jsdval->props.next;
 453         jsdprop != (JSDProperty*)&jsdval->props;
 454         jsdprop = (JSDProperty*)jsdprop->links.next)
 455     {
 456         count++;
 457     }
 458     return count;
 459 }
 460
 461 JSDProperty*
 462 jsd_IterateProperties(JSDContext* jsdc, JSDValue* jsdval, JSDProperty **iterp)
 463 {
 464     JSDProperty* jsdprop = *iterp;
 465     if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PROPS)))
 466     {
 467         JS_ASSERT(!jsdprop);
 468         if(!_buildProps(jsdc, jsdval))
 469             return NULL;
 470     }
 471
 472     if(!jsdprop)
 473         jsdprop = (JSDProperty*)jsdval->props.next;
 474     if(jsdprop == (JSDProperty*)&jsdval->props)
 475         return NULL;
 476     *iterp = (JSDProperty*)jsdprop->links.next;
 477
 478     JS_ASSERT(jsdprop);
 479     jsdprop->nref++;
 480     return jsdprop;
 481 }
 482
 483 JSDProperty*
 484 jsd_GetValueProperty(JSDContext* jsdc, JSDValue* jsdval, JSString* name)
 485 {
 486     JSContext* cx = jsdc->dumbContext;
 487     JSDProperty* jsdprop;
 488     JSDProperty* iter = NULL;
 489     JSObject* obj;
 490     uintN  attrs = 0;
 491     JSBool found;
 492     JSPropertyDesc pd;
 493     const jschar * nameChars;
 494     size_t nameLen;
 495     jsval val;
 496
 497     if(!jsd_IsValueObject(jsdc, jsdval))
 498         return NULL;
 499
 500     /* If we already have the prop, then return it */
 501     while(NULL != (jsdprop = jsd_IterateProperties(jsdc, jsdval, &iter)))
 502     {
 503         JSString* propName = jsd_GetValueString(jsdc, jsdprop->name);
 504         if(propName && !JS_CompareStrings(propName, name))
 505             return jsdprop;
 506         JSD_DropProperty(jsdc, jsdprop);
 507     }
 508     /* Not found in property list, look it up explicitly */
 509
 510     if(!(obj = JSVAL_TO_OBJECT(jsdval->val)))
 511         return NULL;
 512
 513     nameChars = JS_GetStringChars(name);
 514     nameLen   = JS_GetStringLength(name);
 515
 516     JS_BeginRequest(cx);
 517
 518     JS_GetUCPropertyAttributes(cx, obj, nameChars, nameLen, &attrs, &found);
 519     if (!found)
 520     {
 521         JS_EndRequest(cx);
 522         return NULL;
 523     }
 524
 525     JS_ClearPendingException(cx);
 526
 527     if(!JS_GetUCProperty(cx, obj, nameChars, nameLen, &val))
 528     {
 529         if (JS_IsExceptionPending(cx))
 530         {
 531             if (!JS_GetPendingException(cx, &pd.value))
 532             {
 533                 JS_EndRequest(cx);
 534                 return NULL;
 535             }
 536             pd.flags = JSPD_EXCEPTION;
 537         }
 538         else
 539         {
 540             pd.flags = JSPD_ERROR;
 541             pd.value = JSVAL_VOID;
 542         }
 543     }
 544     else
 545     {
 546         pd.value = val;
 547     }
 548
 549     JS_EndRequest(cx);
 550
 551     pd.id = STRING_TO_JSVAL(name);
 552     pd.alias = pd.slot = pd.spare = 0;
 553     pd.flags |= (attrs & JSPROP_ENUMERATE) ? JSPD_ENUMERATE : 0
 554         | (attrs & JSPROP_READONLY)  ? JSPD_READONLY  : 0
 555         | (attrs & JSPROP_PERMANENT) ? JSPD_PERMANENT : 0;
 556
 557     return _newProperty(jsdc, &pd, JSDPD_HINTED);
 558 }
 559
 560
 561 JSDValue*
 562 jsd_GetValuePrototype(JSDContext* jsdc, JSDValue* jsdval)
 563 {
 564     if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PROTO)))
 565     {
 566         JSObject* obj;
 567         JSObject* proto;
 568         JS_ASSERT(!jsdval->proto);
 569         SET_BIT_FLAG(jsdval->flags, GOT_PROTO);
 570         if(!JSVAL_IS_OBJECT(jsdval->val))
 571             return NULL;
 572         if(!(obj = JSVAL_TO_OBJECT(jsdval->val)))
 573             return NULL;
 574         JS_BeginRequest(jsdc->dumbContext);
 575         proto = JS_GetPrototype(jsdc->dumbContext, obj);
 576         JS_EndRequest(jsdc->dumbContext);
 577         if(!proto)
 578             return NULL;
 579         jsdval->proto = jsd_NewValue(jsdc, OBJECT_TO_JSVAL(proto));
 580     }
 581     if(jsdval->proto)
 582         jsdval->proto->nref++;
 583     return jsdval->proto;
 584 }
 585
 586 JSDValue*
 587 jsd_GetValueParent(JSDContext* jsdc, JSDValue* jsdval)
 588 {
 589     if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PARENT)))
 590     {
 591         JSObject* obj;
 592         JSObject* parent;
 593         JS_ASSERT(!jsdval->parent);
 594         SET_BIT_FLAG(jsdval->flags, GOT_PARENT);
 595         if(!JSVAL_IS_OBJECT(jsdval->val))
 596             return NULL;
 597         if(!(obj = JSVAL_TO_OBJECT(jsdval->val)))
 598             return NULL;
 599         JS_BeginRequest(jsdc->dumbContext);
 600         parent = JS_GetParent(jsdc->dumbContext,obj);
 601         JS_EndRequest(jsdc->dumbContext);
 602         if(!parent)
 603             return NULL;
 604         jsdval->parent = jsd_NewValue(jsdc, OBJECT_TO_JSVAL(parent));
 605     }
 606     if(jsdval->parent)
 607         jsdval->parent->nref++;
 608     return jsdval->parent;
 609 }
 610
 611 JSDValue*
 612 jsd_GetValueConstructor(JSDContext* jsdc, JSDValue* jsdval)
 613 {
 614     if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_CTOR)))
 615     {
 616         JSObject* obj;
 617         JSObject* proto;
 618         JSObject* ctor;
 619         JS_ASSERT(!jsdval->ctor);
 620         SET_BIT_FLAG(jsdval->flags, GOT_CTOR);
 621         if(!JSVAL_IS_OBJECT(jsdval->val))
 622             return NULL;
 623         if(!(obj = JSVAL_TO_OBJECT(jsdval->val)))
 624             return NULL;
 625         JS_BeginRequest(jsdc->dumbContext);
 626         proto = JS_GetPrototype(jsdc->dumbContext,obj);
 627         if(!proto)
 628         {
 629             JS_EndRequest(jsdc->dumbContext);
 630             return NULL;
 631         }
 632         ctor = JS_GetConstructor(jsdc->dumbContext,proto);
 633         JS_EndRequest(jsdc->dumbContext);
 634         if(!ctor)
 635             return NULL;
 636         jsdval->ctor = jsd_NewValue(jsdc, OBJECT_TO_JSVAL(ctor));
 637     }
 638     if(jsdval->ctor)
 639         jsdval->ctor->nref++;
 640     return jsdval->ctor;
 641 }
 642
 643 const char*
 644 jsd_GetValueClassName(JSDContext* jsdc, JSDValue* jsdval)
 645 {
 646     jsval val = jsdval->val;
 647     if(!jsdval->className && JSVAL_IS_OBJECT(val))
 648     {
 649         JSObject* obj;
 650         if(!(obj = JSVAL_TO_OBJECT(val)))
 651             return NULL;
 652         JS_BeginRequest(jsdc->dumbContext);
 653         if(JS_GET_CLASS(jsdc->dumbContext, obj))
 654             jsdval->className = JS_GET_CLASS(jsdc->dumbContext, obj)->name;
 655         JS_EndRequest(jsdc->dumbContext);
 656     }
 657     return jsdval->className;
 658 }
 659
 660 JSDScript*
 661 jsd_GetScriptForValue(JSDContext* jsdc, JSDValue* jsdval)
 662 {
 663     JSContext* cx = jsdc->dumbContext;
 664     jsval val = jsdval->val;
 665     JSFunction* fun;
 666     JSExceptionState* exceptionState;
 667     JSScript* script = NULL;
 668     JSDScript* jsdscript;
 669
 670     if (!jsd_IsValueFunction(jsdc, jsdval))
 671         return NULL;
 672
 673     JS_BeginRequest(cx);
 674     exceptionState = JS_SaveExceptionState(cx);
 675     fun = JS_ValueToFunction(cx, val);
 676     JS_RestoreExceptionState(cx, exceptionState);
 677     if (fun)
 678         script = JS_GetFunctionScript(cx, fun);
 679     JS_EndRequest(cx);
 680
 681     if (!script)
 682         return NULL;
 683
 684     JSD_LOCK_SCRIPTS(jsdc);
 685     jsdscript = jsd_FindJSDScript(jsdc, script);
 686     JSD_UNLOCK_SCRIPTS(jsdc);
 687     return jsdscript;
 688 }
 689
 690
 691 /***************************************************************************/
 692 /***************************************************************************/
 693
 694 JSDValue*
 695 jsd_GetPropertyName(JSDContext* jsdc, JSDProperty* jsdprop)
 696 {
 697     jsdprop->name->nref++;
 698     return jsdprop->name;
 699 }
 700
 701 JSDValue*
 702 jsd_GetPropertyValue(JSDContext* jsdc, JSDProperty* jsdprop)
 703 {
 704     jsdprop->val->nref++;
 705     return jsdprop->val;
 706 }
 707
 708 JSDValue*
 709 jsd_GetPropertyAlias(JSDContext* jsdc, JSDProperty* jsdprop)
 710 {
 711     if(jsdprop->alias)
 712         jsdprop->alias->nref++;
 713     return jsdprop->alias;
 714 }
 715
 716 uintN
 717 jsd_GetPropertyFlags(JSDContext* jsdc, JSDProperty* jsdprop)
 718 {
 719     return jsdprop->flags;
 720 }
 721
 722 uintN
 723 jsd_GetPropertyVarArgSlot(JSDContext* jsdc, JSDProperty* jsdprop)
 724 {
 725     return jsdprop->slot;
 726 }
 727
 728 void
 729 jsd_DropProperty(JSDContext* jsdc, JSDProperty* jsdprop)
 730 {
 731     JS_ASSERT(jsdprop->nref > 0);
 732     if(0 == --jsdprop->nref)
 733     {
 734         JS_ASSERT(JS_CLIST_IS_EMPTY(&jsdprop->links));
 735         DROP_CLEAR_VALUE(jsdc, jsdprop->val);
 736         DROP_CLEAR_VALUE(jsdc, jsdprop->name);
 737         DROP_CLEAR_VALUE(jsdc, jsdprop->alias);
 738         free(jsdprop);
 739     }
 740 }