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
  44 #ifdef DEBUG
  45 void JSD_ASSERT_VALID_VALUE(JSDValue* jsdval)
  46 {
  47     JS_ASSERT(jsdval);
  48     JS_ASSERT(jsdval->nref > 0);
  49     if(!JS_CLIST_IS_EMPTY(&jsdval->props))
  50     {
  51         JS_ASSERT(CHECK_BIT_FLAG(jsdval->flags, GOT_PROPS));
  52         JS_ASSERT(JSVAL_IS_OBJECT(jsdval->val));
  53     }
  54
  55     if(jsdval->proto)
  56     {
  57         JS_ASSERT(CHECK_BIT_FLAG(jsdval->flags, GOT_PROTO));
  58         JS_ASSERT(jsdval->proto->nref > 0);
  59     }
  60     if(jsdval->parent)
  61     {
  62         JS_ASSERT(CHECK_BIT_FLAG(jsdval->flags, GOT_PARENT));
  63         JS_ASSERT(jsdval->parent->nref > 0);
  64     }
  65     if(jsdval->ctor)
  66     {
  67         JS_ASSERT(CHECK_BIT_FLAG(jsdval->flags, GOT_CTOR));
  68         JS_ASSERT(jsdval->ctor->nref > 0);
  69     }
  70 }
  71
  72 void JSD_ASSERT_VALID_PROPERTY(JSDProperty* jsdprop)
  73 {
  74     JS_ASSERT(jsdprop);
  75     JS_ASSERT(jsdprop->name);
  76     JS_ASSERT(jsdprop->name->nref > 0);
  77     JS_ASSERT(jsdprop->val);
  78     JS_ASSERT(jsdprop->val->nref > 0);
  79     if(jsdprop->alias)
  80         JS_ASSERT(jsdprop->alias->nref > 0);
  81 }
  82 #endif
  83
  84
  85 JSBool
  86 jsd_IsValueObject(JSDContext* jsdc, JSDValue* jsdval)
  87 {
  88     return JSVAL_IS_OBJECT(jsdval->val);
  89 }
  90
  91 JSBool
  92 jsd_IsValueNumber(JSDContext* jsdc, JSDValue* jsdval)
  93 {
  94     return JSVAL_IS_NUMBER(jsdval->val);
  95 }
  96
  97 JSBool
  98 jsd_IsValueInt(JSDContext* jsdc, JSDValue* jsdval)
  99 {
 100     return JSVAL_IS_INT(jsdval->val);
 101 }
 102
 103 JSBool
 104 jsd_IsValueDouble(JSDContext* jsdc, JSDValue* jsdval)
 105 {
 106     return JSVAL_IS_DOUBLE(jsdval->val);
 107 }
 108
 109 JSBool
 110 jsd_IsValueString(JSDContext* jsdc, JSDValue* jsdval)
 111 {
 112     return JSVAL_IS_STRING(jsdval->val);
 113 }
 114
 115 JSBool
 116 jsd_IsValueBoolean(JSDContext* jsdc, JSDValue* jsdval)
 117 {
 118     return JSVAL_IS_BOOLEAN(jsdval->val);
 119 }
 120
 121 JSBool
 122 jsd_IsValueNull(JSDContext* jsdc, JSDValue* jsdval)
 123 {
 124     return JSVAL_IS_NULL(jsdval->val);
 125 }
 126
 127 JSBool
 128 jsd_IsValueVoid(JSDContext* jsdc, JSDValue* jsdval)
 129 {
 130     return JSVAL_IS_VOID(jsdval->val);
 131 }
 132
 133 JSBool
 134 jsd_IsValuePrimitive(JSDContext* jsdc, JSDValue* jsdval)
 135 {
 136     return JSVAL_IS_PRIMITIVE(jsdval->val);
 137 }
 138
 139 JSBool
 140 jsd_IsValueFunction(JSDContext* jsdc, JSDValue* jsdval)
 141 {
 142     return !JSVAL_IS_PRIMITIVE(jsdval->val) &&
 143            JS_ObjectIsFunction(jsdc->dumbContext, JSVAL_TO_OBJECT(jsdval->val));
 144 }
 145
 146 JSBool
 147 jsd_IsValueNative(JSDContext* jsdc, JSDValue* jsdval)
 148 {
 149     JSContext* cx = jsdc->dumbContext;
 150     jsval val = jsdval->val;
 151     JSFunction* fun;
 152     JSExceptionState* exceptionState;
 153
 154     if(jsd_IsValueFunction(jsdc, jsdval))
 155     {
 156         JSBool ok = JS_FALSE;
 157         JS_BeginRequest(cx);
 158         exceptionState = JS_SaveExceptionState(cx);
 159         fun = JS_ValueToFunction(cx, val);
 160         JS_RestoreExceptionState(cx, exceptionState);
 161         if(fun)
 162             ok = JS_GetFunctionScript(cx, fun) ? JS_FALSE : JS_TRUE;
 163         JS_EndRequest(cx);
 164         JS_ASSERT(fun);
 165         return ok;
 166     }
 167     return !JSVAL_IS_PRIMITIVE(val);
 168 }
 169
 170 /***************************************************************************/
 171
 172 JSBool
 173 jsd_GetValueBoolean(JSDContext* jsdc, JSDValue* jsdval)
 174 {
 175     jsval val = jsdval->val;
 176     if(!JSVAL_IS_BOOLEAN(val))
 177         return JS_FALSE;
 178     return JSVAL_TO_BOOLEAN(val);
 179 }
 180
 181 int32
 182 jsd_GetValueInt(JSDContext* jsdc, JSDValue* jsdval)
 183 {
 184     jsval val = jsdval->val;
 185     if(!JSVAL_IS_INT(val))
 186         return 0;
 187     return JSVAL_TO_INT(val);
 188 }
 189
 190 jsdouble*
 191 jsd_GetValueDouble(JSDContext* jsdc, JSDValue* jsdval)
 192 {
 193     jsval val = jsdval->val;
 194     if(!JSVAL_IS_DOUBLE(val))
 195         return 0;
 196     return JSVAL_TO_DOUBLE(val);
 197 }
 198
 199 JSString*
 200 jsd_GetValueString(JSDContext* jsdc, JSDValue* jsdval)
 201 {
 202     JSContext* cx = jsdc->dumbContext;
 203     JSExceptionState* exceptionState;
 204
 205     if(!jsdval->string)
 206     {
 207         /* if the jsval is a string, then we don't need to double root it */
 208         if(JSVAL_IS_STRING(jsdval->val))
 209             jsdval->string = JSVAL_TO_STRING(jsdval->val);
 210         else
 211         {
 212             JS_BeginRequest(cx);
 213             exceptionState = JS_SaveExceptionState(cx);
 214             jsdval->string = JS_ValueToString(cx, jsdval->val);
 215             JS_RestoreExceptionState(cx, exceptionState);
 216             if(jsdval->string)
 217             {
 218                 if(!JS_AddNamedRoot(cx, &jsdval->string, "ValueString"))
 219                     jsdval->string = NULL;
 220             }
 221             JS_EndRequest(cx);
 222         }
 223     }
 224     return jsdval->string;
 225 }
 226
 227 const char*
 228 jsd_GetValueFunctionName(JSDContext* jsdc, JSDValue* jsdval)
 229 {
 230     JSContext* cx = jsdc->dumbContext;
 231     JSFunction* fun;
 232     JSExceptionState* exceptionState;
 233
 234     if(!jsdval->funName && jsd_IsValueFunction(jsdc, jsdval))
 235     {
 236         JS_BeginRequest(cx);
 237         exceptionState = JS_SaveExceptionState(cx);
 238         fun = JS_ValueToFunction(cx, jsdval->val);
 239         JS_RestoreExceptionState(cx, exceptionState);
 240         JS_EndRequest(cx);
 241         if(!fun)
 242             return NULL;
 243         jsdval->funName = JS_GetFunctionName(fun);
 244     }
 245     return jsdval->funName;
 246 }
 247
 248 /***************************************************************************/
 249
 250 JSDValue*
 251 jsd_NewValue(JSDContext* jsdc, jsval val)
 252 {
 253     JSDValue* jsdval;
 254
 255     if(!(jsdval = (JSDValue*) calloc(1, sizeof(JSDValue))))
 256         return NULL;
 257
 258     if(JSVAL_IS_GCTHING(val))
 259     {
 260         JSBool ok = JS_FALSE;
 261         JS_BeginRequest(jsdc->dumbContext);
 262         ok = JS_AddNamedRoot(jsdc->dumbContext, &jsdval->val, "JSDValue");
 263         JS_EndRequest(jsdc->dumbContext);
 264         if(!ok)
 265         {
 266             free(jsdval);
 267             return NULL;
 268         }
 269     }
 270     jsdval->val  = val;
 271     jsdval->nref = 1;
 272     JS_INIT_CLIST(&jsdval->props);
 273
 274     return jsdval;
 275 }
 276
 277 void
 278 jsd_DropValue(JSDContext* jsdc, JSDValue* jsdval)
 279 {
 280     JS_ASSERT(jsdval->nref > 0);
 281     if(0 == --jsdval->nref)
 282     {
 283         jsd_RefreshValue(jsdc, jsdval);
 284         if(JSVAL_IS_GCTHING(jsdval->val))
 285         {
 286             JS_BeginRequest(jsdc->dumbContext);
 287             JS_RemoveRoot(jsdc->dumbContext, &jsdval->val);
 288             JS_EndRequest(jsdc->dumbContext);
 289         }
 290         free(jsdval);
 291     }
 292 }
 293
 294 jsval
 295 jsd_GetValueWrappedJSVal(JSDContext* jsdc, JSDValue* jsdval)
 296 {
 297     return jsdval->val;
 298 }
 299
 300 static JSDProperty* _newProperty(JSDContext* jsdc, JSPropertyDesc* pd,
 301                                  uintN additionalFlags)
 302 {
 303     JSDProperty* jsdprop;
 304
 305     if(!(jsdprop = (JSDProperty*) calloc(1, sizeof(JSDProperty))))
 306         return NULL;
 307
 308     JS_INIT_CLIST(&jsdprop->links);
 309     jsdprop->nref = 1;
 310     jsdprop->flags = pd->flags | additionalFlags;
 311     jsdprop->slot = pd->slot;
 312
 313     if(!(jsdprop->name = jsd_NewValue(jsdc, pd->id)))
 314         goto new_prop_fail;
 315
 316     if(!(jsdprop->val = jsd_NewValue(jsdc, pd->value)))
 317         goto new_prop_fail;
 318
 319     if((jsdprop->flags & JSDPD_ALIAS) &&
 320        !(jsdprop->alias = jsd_NewValue(jsdc, pd->alias)))
 321         goto new_prop_fail;
 322
 323     return jsdprop;
 324 new_prop_fail:
 325     jsd_DropProperty(jsdc, jsdprop);
 326     return NULL;
 327 }
 328
 329 static void _freeProps(JSDContext* jsdc, JSDValue* jsdval)
 330 {
 331     JSDProperty* jsdprop;
 332
 333     while(jsdprop = (JSDProperty*)jsdval->props.next,
 334           jsdprop != (JSDProperty*)&jsdval->props)
 335     {
 336         JS_REMOVE_AND_INIT_LINK(&jsdprop->links);
 337         jsd_DropProperty(jsdc, jsdprop);
 338     }
 339     JS_ASSERT(JS_CLIST_IS_EMPTY(&jsdval->props));
 340     CLEAR_BIT_FLAG(jsdval->flags, GOT_PROPS);
 341 }
 342
 343 static JSBool _buildProps(JSDContext* jsdc, JSDValue* jsdval)
 344 {
 345     JSContext* cx = jsdc->dumbContext;
 346     JSPropertyDescArray pda;
 347     uintN i;
 348
 349     JS_ASSERT(JS_CLIST_IS_EMPTY(&jsdval->props));
 350     JS_ASSERT(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PROPS)));
 351     JS_ASSERT(JSVAL_IS_OBJECT(jsdval->val));
 352
 353     if(!JSVAL_IS_OBJECT(jsdval->val) || JSVAL_IS_NULL(jsdval->val))
 354         return JS_FALSE;
 355
 356     JS_BeginRequest(cx);
 357     if(!JS_GetPropertyDescArray(cx, JSVAL_TO_OBJECT(jsdval->val), &pda))
 358     {
 359         JS_EndRequest(cx);
 360         return JS_FALSE;
 361     }
 362
 363     for(i = 0; i < pda.length; i++)
 364     {
 365         JSDProperty* prop = _newProperty(jsdc, &pda.array[i], 0);
 366         if(!prop)
 367         {
 368             _freeProps(jsdc, jsdval);
 369             break;
 370         }
 371         JS_APPEND_LINK(&prop->links, &jsdval->props);
 372     }
 373     JS_PutPropertyDescArray(cx, &pda);
 374     JS_EndRequest(cx);
 375     SET_BIT_FLAG(jsdval->flags, GOT_PROPS);
 376     return !JS_CLIST_IS_EMPTY(&jsdval->props);
 377 }
 378
 379 #undef  DROP_CLEAR_VALUE
 380 #define DROP_CLEAR_VALUE(jsdc, x) if(x){jsd_DropValue(jsdc,x); x = NULL;}
 381
 382 void
 383 jsd_RefreshValue(JSDContext* jsdc, JSDValue* jsdval)
 384 {
 385     JSContext* cx = jsdc->dumbContext;
 386
 387     if(jsdval->string)
 388     {
 389         /* if the jsval is a string, then we didn't need to root the string */
 390         if(!JSVAL_IS_STRING(jsdval->val))
 391         {
 392             JS_BeginRequest(cx);
 393             JS_RemoveRoot(cx, &jsdval->string);
 394             JS_EndRequest(cx);
 395         }
 396         jsdval->string = NULL;
 397     }
 398
 399     jsdval->funName = NULL;
 400     jsdval->className = NULL;
 401     DROP_CLEAR_VALUE(jsdc, jsdval->proto);
 402     DROP_CLEAR_VALUE(jsdc, jsdval->parent);
 403     DROP_CLEAR_VALUE(jsdc, jsdval->ctor);
 404     _freeProps(jsdc, jsdval);
 405     jsdval->flags = 0;
 406 }
 407
 408 /***************************************************************************/
 409
 410 uintN
 411 jsd_GetCountOfProperties(JSDContext* jsdc, JSDValue* jsdval)
 412 {
 413     JSDProperty* jsdprop;
 414     uintN count = 0;
 415
 416     if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PROPS)))
 417         if(!_buildProps(jsdc, jsdval))
 418             return 0;
 419
 420     for(jsdprop = (JSDProperty*)jsdval->props.next;
 421         jsdprop != (JSDProperty*)&jsdval->props;
 422         jsdprop = (JSDProperty*)jsdprop->links.next)
 423     {
 424         count++;
 425     }
 426     return count;
 427 }
 428
 429 JSDProperty*
 430 jsd_IterateProperties(JSDContext* jsdc, JSDValue* jsdval, JSDProperty **iterp)
 431 {
 432     JSDProperty* jsdprop = *iterp;
 433     if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PROPS)))
 434     {
 435         JS_ASSERT(!jsdprop);
 436         if(!_buildProps(jsdc, jsdval))
 437             return NULL;
 438     }
 439
 440     if(!jsdprop)
 441         jsdprop = (JSDProperty*)jsdval->props.next;
 442     if(jsdprop == (JSDProperty*)&jsdval->props)
 443         return NULL;
 444     *iterp = (JSDProperty*)jsdprop->links.next;
 445
 446     JS_ASSERT(jsdprop);
 447     jsdprop->nref++;
 448     return jsdprop;
 449 }
 450
 451 JSDProperty*
 452 jsd_GetValueProperty(JSDContext* jsdc, JSDValue* jsdval, JSString* name)
 453 {
 454     JSContext* cx = jsdc->dumbContext;
 455     JSDProperty* jsdprop;
 456     JSDProperty* iter = NULL;
 457     JSObject* obj;
 458     uintN  attrs = 0;
 459     JSBool found;
 460     JSPropertyDesc pd;
 461     const jschar * nameChars;
 462     size_t nameLen;
 463     jsval val;
 464
 465     if(!jsd_IsValueObject(jsdc, jsdval))
 466         return NULL;
 467
 468     /* If we already have the prop, then return it */
 469     while(NULL != (jsdprop = jsd_IterateProperties(jsdc, jsdval, &iter)))
 470     {
 471         JSString* propName = jsd_GetValueString(jsdc, jsdprop->name);
 472         if(propName && !JS_CompareStrings(propName, name))
 473             return jsdprop;
 474         JSD_DropProperty(jsdc, jsdprop);
 475     }
 476     /* Not found in property list, look it up explicitly */
 477
 478     if(!(obj = JSVAL_TO_OBJECT(jsdval->val)))
 479         return NULL;
 480
 481     nameChars = JS_GetStringChars(name);
 482     nameLen   = JS_GetStringLength(name);
 483
 484     JS_BeginRequest(cx);
 485
 486     JS_GetUCPropertyAttributes(cx, obj, nameChars, nameLen, &attrs, &found);
 487     if (!found)
 488     {
 489         JS_EndRequest(cx);
 490         return NULL;
 491     }
 492
 493     JS_ClearPendingException(cx);
 494
 495     if(!JS_GetUCProperty(cx, obj, nameChars, nameLen, &val))
 496     {
 497         if (JS_IsExceptionPending(cx))
 498         {
 499             if (!JS_GetPendingException(cx, &pd.value))
 500             {
 501                 JS_EndRequest(cx);
 502                 return NULL;
 503             }
 504             pd.flags = JSPD_EXCEPTION;
 505         }
 506         else
 507         {
 508             pd.flags = JSPD_ERROR;
 509             pd.value = JSVAL_VOID;
 510         }
 511     }
 512     else
 513     {
 514         pd.value = val;
 515     }
 516
 517     JS_EndRequest(cx);
 518
 519     pd.id = STRING_TO_JSVAL(name);
 520     pd.alias = pd.slot = pd.spare = 0;
 521     pd.flags |= (attrs & JSPROP_ENUMERATE) ? JSPD_ENUMERATE : 0
 522         | (attrs & JSPROP_READONLY)  ? JSPD_READONLY  : 0
 523         | (attrs & JSPROP_PERMANENT) ? JSPD_PERMANENT : 0;
 524
 525     return _newProperty(jsdc, &pd, JSDPD_HINTED);
 526 }
 527
 528
 529 JSDValue*
 530 jsd_GetValuePrototype(JSDContext* jsdc, JSDValue* jsdval)
 531 {
 532     if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PROTO)))
 533     {
 534         JSObject* obj;
 535         JSObject* proto;
 536         JS_ASSERT(!jsdval->proto);
 537         SET_BIT_FLAG(jsdval->flags, GOT_PROTO);
 538         if(!JSVAL_IS_OBJECT(jsdval->val))
 539             return NULL;
 540         if(!(obj = JSVAL_TO_OBJECT(jsdval->val)))
 541             return NULL;
 542         JS_BeginRequest(jsdc->dumbContext);
 543         proto = JS_GetPrototype(jsdc->dumbContext, obj);
 544         JS_EndRequest(jsdc->dumbContext);
 545         if(!proto)
 546             return NULL;
 547         jsdval->proto = jsd_NewValue(jsdc, OBJECT_TO_JSVAL(proto));
 548     }
 549     if(jsdval->proto)
 550         jsdval->proto->nref++;
 551     return jsdval->proto;
 552 }
 553
 554 JSDValue*
 555 jsd_GetValueParent(JSDContext* jsdc, JSDValue* jsdval)
 556 {
 557     if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_PARENT)))
 558     {
 559         JSObject* obj;
 560         JSObject* parent;
 561         JS_ASSERT(!jsdval->parent);
 562         SET_BIT_FLAG(jsdval->flags, GOT_PARENT);
 563         if(!JSVAL_IS_OBJECT(jsdval->val))
 564             return NULL;
 565         if(!(obj = JSVAL_TO_OBJECT(jsdval->val)))
 566             return NULL;
 567         JS_BeginRequest(jsdc->dumbContext);
 568         parent = JS_GetParent(jsdc->dumbContext,obj);
 569         JS_EndRequest(jsdc->dumbContext);
 570         if(!parent)
 571             return NULL;
 572         jsdval->parent = jsd_NewValue(jsdc, OBJECT_TO_JSVAL(parent));
 573     }
 574     if(jsdval->parent)
 575         jsdval->parent->nref++;
 576     return jsdval->parent;
 577 }
 578
 579 JSDValue*
 580 jsd_GetValueConstructor(JSDContext* jsdc, JSDValue* jsdval)
 581 {
 582     if(!(CHECK_BIT_FLAG(jsdval->flags, GOT_CTOR)))
 583     {
 584         JSObject* obj;
 585         JSObject* proto;
 586         JSObject* ctor;
 587         JS_ASSERT(!jsdval->ctor);
 588         SET_BIT_FLAG(jsdval->flags, GOT_CTOR);
 589         if(!JSVAL_IS_OBJECT(jsdval->val))
 590             return NULL;
 591         if(!(obj = JSVAL_TO_OBJECT(jsdval->val)))
 592             return NULL;
 593         JS_BeginRequest(jsdc->dumbContext);
 594         proto = JS_GetPrototype(jsdc->dumbContext,obj);
 595         if(!proto)
 596         {
 597             JS_EndRequest(jsdc->dumbContext);
 598             return NULL;
 599         }
 600         ctor = JS_GetConstructor(jsdc->dumbContext,proto);
 601         JS_EndRequest(jsdc->dumbContext);
 602         if(!ctor)
 603             return NULL;
 604         jsdval->ctor = jsd_NewValue(jsdc, OBJECT_TO_JSVAL(ctor));
 605     }
 606     if(jsdval->ctor)
 607         jsdval->ctor->nref++;
 608     return jsdval->ctor;
 609 }
 610
 611 const char*
 612 jsd_GetValueClassName(JSDContext* jsdc, JSDValue* jsdval)
 613 {
 614     jsval val = jsdval->val;
 615     if(!jsdval->className && JSVAL_IS_OBJECT(val))
 616     {
 617         JSObject* obj;
 618         if(!(obj = JSVAL_TO_OBJECT(val)))
 619             return NULL;
 620         JS_BeginRequest(jsdc->dumbContext);
 621         if(JS_GET_CLASS(jsdc->dumbContext, obj))
 622             jsdval->className = JS_GET_CLASS(jsdc->dumbContext, obj)->name;
 623         JS_EndRequest(jsdc->dumbContext);
 624     }
 625     return jsdval->className;
 626 }
 627
 628 /***************************************************************************/
 629 /***************************************************************************/
 630
 631 JSDValue*
 632 jsd_GetPropertyName(JSDContext* jsdc, JSDProperty* jsdprop)
 633 {
 634     jsdprop->name->nref++;
 635     return jsdprop->name;
 636 }
 637
 638 JSDValue*
 639 jsd_GetPropertyValue(JSDContext* jsdc, JSDProperty* jsdprop)
 640 {
 641     jsdprop->val->nref++;
 642     return jsdprop->val;
 643 }
 644
 645 JSDValue*
 646 jsd_GetPropertyAlias(JSDContext* jsdc, JSDProperty* jsdprop)
 647 {
 648     if(jsdprop->alias)
 649         jsdprop->alias->nref++;
 650     return jsdprop->alias;
 651 }
 652
 653 uintN
 654 jsd_GetPropertyFlags(JSDContext* jsdc, JSDProperty* jsdprop)
 655 {
 656     return jsdprop->flags;
 657 }
 658
 659 uintN
 660 jsd_GetPropertyVarArgSlot(JSDContext* jsdc, JSDProperty* jsdprop)
 661 {
 662     return jsdprop->slot;
 663 }
 664
 665 void
 666 jsd_DropProperty(JSDContext* jsdc, JSDProperty* jsdprop)
 667 {
 668     JS_ASSERT(jsdprop->nref > 0);
 669     if(0 == --jsdprop->nref)
 670     {
 671         JS_ASSERT(JS_CLIST_IS_EMPTY(&jsdprop->links));
 672         DROP_CLEAR_VALUE(jsdc, jsdprop->val);
 673         DROP_CLEAR_VALUE(jsdc, jsdprop->name);
 674         DROP_CLEAR_VALUE(jsdc, jsdprop->alias);
 675         free(jsdprop);
 676     }
 677 }