js/jsd/jsdebug.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 - All public functions
  40  */
  41
  42 #include "jsd.h"
  43
  44 /***************************************************************************/
  45 /* High Level calls */
  46
  47 JSD_PUBLIC_API(JSDContext*)
  48 JSD_DebuggerOnForUser(JSRuntime*         jsrt,
  49                       JSD_UserCallbacks* callbacks,
  50                       void*              user)
  51 {
  52     return jsd_DebuggerOnForUser(jsrt, callbacks, user);
  53 }
  54
  55 JSD_PUBLIC_API(JSDContext*)
  56 JSD_DebuggerOn(void)
  57 {
  58     return jsd_DebuggerOn();
  59 }
  60
  61 JSD_PUBLIC_API(void)
  62 JSD_DebuggerOff(JSDContext* jsdc)
  63 {
  64     JSD_ASSERT_VALID_CONTEXT(jsdc);
  65     jsd_DebuggerOff(jsdc);
  66 }
  67
  68
  69 JSD_PUBLIC_API(uintN)
  70 JSD_GetMajorVersion(void)
  71 {
  72     return JSD_MAJOR_VERSION;
  73 }
  74
  75 JSD_PUBLIC_API(uintN)
  76 JSD_GetMinorVersion(void)
  77 {
  78     return JSD_MINOR_VERSION;
  79 }
  80
  81 JSD_PUBLIC_API(JSContext*)
  82 JSD_GetDefaultJSContext(JSDContext* jsdc)
  83 {
  84     JSD_ASSERT_VALID_CONTEXT(jsdc);
  85     return jsdc->dumbContext;
  86 }
  87
  88 JSD_PUBLIC_API(void)
  89 JSD_SetUserCallbacks(JSRuntime* jsrt, JSD_UserCallbacks* callbacks, void* user)
  90 {
  91     jsd_SetUserCallbacks(jsrt, callbacks, user);
  92 }
  93
  94 JSD_PUBLIC_API(void)
  95 JSD_JSContextInUse(JSDContext* jsdc, JSContext* context)
  96 {
  97     JSD_ASSERT_VALID_CONTEXT(jsdc);
  98     /* we no longer need this information - may need it again in the future */
  99 }
 100
 101 JSD_PUBLIC_API(void *)
 102 JSD_SetContextPrivate(JSDContext *jsdc, void *data)
 103 {
 104     JSD_ASSERT_VALID_CONTEXT(jsdc);
 105     return jsd_SetContextPrivate (jsdc, data);
 106 }
 107
 108 JSD_PUBLIC_API(void *)
 109 JSD_GetContextPrivate(JSDContext *jsdc)
 110 {
 111     JSD_ASSERT_VALID_CONTEXT(jsdc);
 112     return jsd_GetContextPrivate (jsdc);
 113 }
 114
 115 JSD_PUBLIC_API(void)
 116 JSD_ClearAllProfileData(JSDContext *jsdc)
 117 {
 118     JSD_ASSERT_VALID_CONTEXT(jsdc);
 119     jsd_ClearAllProfileData(jsdc);
 120 }
 121
 122 JSD_PUBLIC_API(void)
 123 JSD_SetContextFlags(JSDContext *jsdc, uint32 flags)
 124 {
 125     JSD_ASSERT_VALID_CONTEXT(jsdc);
 126     jsdc->flags = flags;
 127 }
 128
 129 JSD_PUBLIC_API(uint32)
 130 JSD_GetContextFlags(JSDContext *jsdc)
 131 {
 132     JSD_ASSERT_VALID_CONTEXT(jsdc);
 133     return jsdc->flags;
 134 }
 135
 136 JSD_PUBLIC_API(JSDContext*)
 137 JSD_JSDContextForJSContext(JSContext* context)
 138 {
 139     return jsd_JSDContextForJSContext(context);
 140 }
 141
 142 /***************************************************************************/
 143 /* Script functions */
 144
 145 JSD_PUBLIC_API(void)
 146 JSD_LockScriptSubsystem(JSDContext* jsdc)
 147 {
 148     JSD_ASSERT_VALID_CONTEXT(jsdc);
 149     JSD_LOCK_SCRIPTS(jsdc);
 150 }
 151
 152 JSD_PUBLIC_API(void)
 153 JSD_UnlockScriptSubsystem(JSDContext* jsdc)
 154 {
 155     JSD_ASSERT_VALID_CONTEXT(jsdc);
 156     JSD_UNLOCK_SCRIPTS(jsdc);
 157 }
 158
 159 JSD_PUBLIC_API(JSDScript*)
 160 JSD_IterateScripts(JSDContext* jsdc, JSDScript **iterp)
 161 {
 162     JSD_ASSERT_VALID_CONTEXT(jsdc);
 163     return jsd_IterateScripts(jsdc, iterp);
 164 }
 165
 166 JSD_PUBLIC_API(uint32)
 167 JSD_GetScriptFlags(JSDContext *jsdc, JSDScript *script)
 168 {
 169     JSD_ASSERT_VALID_CONTEXT(jsdc);
 170     return jsd_GetScriptFlags(jsdc, script);
 171 }
 172
 173 JSD_PUBLIC_API(void)
 174 JSD_SetScriptFlags(JSDContext *jsdc, JSDScript *script, uint32 flags)
 175 {
 176     JSD_ASSERT_VALID_CONTEXT(jsdc);
 177     jsd_SetScriptFlags(jsdc, script, flags);
 178 }
 179
 180 JSD_PUBLIC_API(uintN)
 181 JSD_GetScriptCallCount(JSDContext* jsdc, JSDScript *script)
 182 {
 183     JSD_ASSERT_VALID_CONTEXT(jsdc);
 184     return jsd_GetScriptCallCount(jsdc, script);
 185 }
 186
 187 JSD_PUBLIC_API(uintN)
 188 JSD_GetScriptMaxRecurseDepth(JSDContext* jsdc, JSDScript *script)
 189 {
 190     JSD_ASSERT_VALID_CONTEXT(jsdc);
 191     return jsd_GetScriptMaxRecurseDepth(jsdc, script);
 192 }
 193
 194
 195 JSD_PUBLIC_API(jsdouble)
 196 JSD_GetScriptMinExecutionTime(JSDContext* jsdc, JSDScript *script)
 197 {
 198     JSD_ASSERT_VALID_CONTEXT(jsdc);
 199     return jsd_GetScriptMinExecutionTime(jsdc, script);
 200 }
 201
 202 JSD_PUBLIC_API(jsdouble)
 203 JSD_GetScriptMaxExecutionTime(JSDContext* jsdc, JSDScript *script)
 204 {
 205     JSD_ASSERT_VALID_CONTEXT(jsdc);
 206     return jsd_GetScriptMaxExecutionTime(jsdc, script);
 207 }
 208
 209 JSD_PUBLIC_API(jsdouble)
 210 JSD_GetScriptTotalExecutionTime(JSDContext* jsdc, JSDScript *script)
 211 {
 212     JSD_ASSERT_VALID_CONTEXT(jsdc);
 213     return jsd_GetScriptTotalExecutionTime(jsdc, script);
 214 }
 215
 216 JSD_PUBLIC_API(jsdouble)
 217 JSD_GetScriptMinOwnExecutionTime(JSDContext* jsdc, JSDScript *script)
 218 {
 219     JSD_ASSERT_VALID_CONTEXT(jsdc);
 220     return jsd_GetScriptMinOwnExecutionTime(jsdc, script);
 221 }
 222
 223 JSD_PUBLIC_API(jsdouble)
 224 JSD_GetScriptMaxOwnExecutionTime(JSDContext* jsdc, JSDScript *script)
 225 {
 226     JSD_ASSERT_VALID_CONTEXT(jsdc);
 227     return jsd_GetScriptMaxOwnExecutionTime(jsdc, script);
 228 }
 229
 230 JSD_PUBLIC_API(jsdouble)
 231 JSD_GetScriptTotalOwnExecutionTime(JSDContext* jsdc, JSDScript *script)
 232 {
 233     JSD_ASSERT_VALID_CONTEXT(jsdc);
 234     return jsd_GetScriptTotalOwnExecutionTime(jsdc, script);
 235 }
 236
 237 JSD_PUBLIC_API(void)
 238 JSD_ClearScriptProfileData(JSDContext* jsdc, JSDScript *script)
 239 {
 240     JSD_ASSERT_VALID_CONTEXT(jsdc);
 241     jsd_ClearScriptProfileData(jsdc, script);
 242 }
 243
 244 JSD_PUBLIC_API(JSScript*)
 245 JSD_GetJSScript(JSDContext* jsdc, JSDScript *script)
 246 {
 247     return jsd_GetJSScript(jsdc, script);
 248 }
 249
 250 JSD_PUBLIC_API(JSFunction*)
 251 JSD_GetJSFunction(JSDContext* jsdc, JSDScript *script)
 252 {
 253     return jsd_GetJSFunction (jsdc, script);
 254 }
 255
 256 JSD_PUBLIC_API(void *)
 257 JSD_SetScriptPrivate(JSDScript *jsdscript, void *data)
 258 {
 259     JSD_ASSERT_VALID_SCRIPT(jsdscript);
 260     return jsd_SetScriptPrivate (jsdscript, data);
 261 }
 262
 263 JSD_PUBLIC_API(void *)
 264 JSD_GetScriptPrivate(JSDScript *jsdscript)
 265 {
 266     JSD_ASSERT_VALID_SCRIPT(jsdscript);
 267     return jsd_GetScriptPrivate (jsdscript);
 268 }
 269
 270
 271 JSD_PUBLIC_API(JSBool)
 272 JSD_IsActiveScript(JSDContext* jsdc, JSDScript *jsdscript)
 273 {
 274     JSD_ASSERT_VALID_CONTEXT(jsdc);
 275     return jsd_IsActiveScript(jsdc, jsdscript);
 276 }
 277
 278 JSD_PUBLIC_API(const char*)
 279 JSD_GetScriptFilename(JSDContext* jsdc, JSDScript *jsdscript)
 280 {
 281     JSD_ASSERT_VALID_CONTEXT(jsdc);
 282     JSD_ASSERT_VALID_SCRIPT(jsdscript);
 283     return jsd_GetScriptFilename(jsdc, jsdscript);
 284 }
 285
 286 JSD_PUBLIC_API(const char*)
 287 JSD_GetScriptFunctionName(JSDContext* jsdc, JSDScript *jsdscript)
 288 {
 289     JSD_ASSERT_VALID_CONTEXT(jsdc);
 290     JSD_ASSERT_VALID_SCRIPT(jsdscript);
 291     return jsd_GetScriptFunctionName(jsdc, jsdscript);
 292 }
 293
 294 JSD_PUBLIC_API(uintN)
 295 JSD_GetScriptBaseLineNumber(JSDContext* jsdc, JSDScript *jsdscript)
 296 {
 297     JSD_ASSERT_VALID_CONTEXT(jsdc);
 298     JSD_ASSERT_VALID_SCRIPT(jsdscript);
 299     return jsd_GetScriptBaseLineNumber(jsdc, jsdscript);
 300 }
 301
 302 JSD_PUBLIC_API(uintN)
 303 JSD_GetScriptLineExtent(JSDContext* jsdc, JSDScript *jsdscript)
 304 {
 305     JSD_ASSERT_VALID_CONTEXT(jsdc);
 306     JSD_ASSERT_VALID_SCRIPT(jsdscript);
 307     return jsd_GetScriptLineExtent(jsdc, jsdscript);
 308 }
 309
 310 JSD_PUBLIC_API(JSBool)
 311 JSD_SetScriptHook(JSDContext* jsdc, JSD_ScriptHookProc hook, void* callerdata)
 312 {
 313     JSD_ASSERT_VALID_CONTEXT(jsdc);
 314     return jsd_SetScriptHook(jsdc, hook, callerdata);
 315 }
 316
 317 JSD_PUBLIC_API(JSBool)
 318 JSD_GetScriptHook(JSDContext* jsdc, JSD_ScriptHookProc* hook, void** callerdata)
 319 {
 320     JSD_ASSERT_VALID_CONTEXT(jsdc);
 321     return jsd_GetScriptHook(jsdc, hook, callerdata);
 322 }
 323
 324 JSD_PUBLIC_API(jsuword)
 325 JSD_GetClosestPC(JSDContext* jsdc, JSDScript* jsdscript, uintN line)
 326 {
 327     JSD_ASSERT_VALID_CONTEXT(jsdc);
 328     JSD_ASSERT_VALID_SCRIPT(jsdscript);
 329     return jsd_GetClosestPC(jsdc, jsdscript, line);
 330 }
 331
 332 JSD_PUBLIC_API(uintN)
 333 JSD_GetClosestLine(JSDContext* jsdc, JSDScript* jsdscript, jsuword pc)
 334 {
 335     JSD_ASSERT_VALID_CONTEXT(jsdc);
 336     JSD_ASSERT_VALID_SCRIPT(jsdscript);
 337     return jsd_GetClosestLine(jsdc, jsdscript, pc);
 338 }
 339
 340 JSD_PUBLIC_API(void)
 341 JSD_ScriptCreated(JSDContext* jsdc,
 342                   JSContext   *cx,
 343                   const char  *filename,    /* URL this script loads from */
 344                   uintN       lineno,       /* line where this script starts */
 345                   JSScript    *script,
 346                   JSFunction  *fun)
 347 {
 348     JSD_ASSERT_VALID_CONTEXT(jsdc);
 349     jsd_ScriptCreated(jsdc, cx, filename, lineno, script, fun);
 350 }
 351
 352 JSD_PUBLIC_API(void)
 353 JSD_ScriptDestroyed(JSDContext* jsdc,
 354                     JSContext   *cx,
 355                     JSScript    *script)
 356 {
 357     JSD_ASSERT_VALID_CONTEXT(jsdc);
 358     jsd_ScriptDestroyed(jsdc, cx, script);
 359 }
 360
 361 /***************************************************************************/
 362 /* Source Text functions */
 363
 364 JSD_PUBLIC_API(void)
 365 JSD_LockSourceTextSubsystem(JSDContext* jsdc)
 366 {
 367     JSD_ASSERT_VALID_CONTEXT(jsdc);
 368     JSD_LOCK_SOURCE_TEXT(jsdc);
 369 }
 370
 371 JSD_PUBLIC_API(void)
 372 JSD_UnlockSourceTextSubsystem(JSDContext* jsdc)
 373 {
 374     JSD_ASSERT_VALID_CONTEXT(jsdc);
 375     JSD_UNLOCK_SOURCE_TEXT(jsdc);
 376 }
 377
 378 JSD_PUBLIC_API(JSDSourceText*)
 379 JSD_IterateSources(JSDContext* jsdc, JSDSourceText **iterp)
 380 {
 381     JSD_ASSERT_VALID_CONTEXT(jsdc);
 382     return jsd_IterateSources(jsdc, iterp);
 383 }
 384
 385 JSD_PUBLIC_API(JSDSourceText*)
 386 JSD_FindSourceForURL(JSDContext* jsdc, const char* url)
 387 {
 388     JSD_ASSERT_VALID_CONTEXT(jsdc);
 389     JS_ASSERT(url);
 390     return jsd_FindSourceForURL(jsdc, url);
 391 }
 392
 393 JSD_PUBLIC_API(const char*)
 394 JSD_GetSourceURL(JSDContext* jsdc, JSDSourceText* jsdsrc)
 395 {
 396     JSD_ASSERT_VALID_CONTEXT(jsdc);
 397     JSD_ASSERT_VALID_SOURCE_TEXT(jsdsrc);
 398     return jsd_GetSourceURL(jsdc,jsdsrc);
 399 }
 400
 401 JSD_PUBLIC_API(JSBool)
 402 JSD_GetSourceText(JSDContext* jsdc, JSDSourceText* jsdsrc,
 403                   const char** ppBuf, intN* pLen)
 404 {
 405     JSD_ASSERT_VALID_CONTEXT(jsdc);
 406     JSD_ASSERT_VALID_SOURCE_TEXT(jsdsrc);
 407     JS_ASSERT(ppBuf);
 408     JS_ASSERT(pLen);
 409     return jsd_GetSourceText(jsdc, jsdsrc, ppBuf, pLen);
 410 }
 411
 412 JSD_PUBLIC_API(void)
 413 JSD_ClearSourceText(JSDContext* jsdc, JSDSourceText* jsdsrc)
 414 {
 415     JSD_ASSERT_VALID_CONTEXT(jsdc);
 416     JSD_ASSERT_VALID_SOURCE_TEXT(jsdsrc);
 417     jsd_ClearSourceText(jsdc, jsdsrc);
 418 }
 419
 420
 421 JSD_PUBLIC_API(JSDSourceStatus)
 422 JSD_GetSourceStatus(JSDContext* jsdc, JSDSourceText* jsdsrc)
 423 {
 424     JSD_ASSERT_VALID_CONTEXT(jsdc);
 425     JSD_ASSERT_VALID_SOURCE_TEXT(jsdsrc);
 426     return jsd_GetSourceStatus(jsdc, jsdsrc);
 427 }
 428
 429 JSD_PUBLIC_API(JSBool)
 430 JSD_IsSourceDirty(JSDContext* jsdc, JSDSourceText* jsdsrc)
 431 {
 432     JSD_ASSERT_VALID_CONTEXT(jsdc);
 433     JSD_ASSERT_VALID_SOURCE_TEXT(jsdsrc);
 434     return jsd_IsSourceDirty(jsdc, jsdsrc);
 435 }
 436
 437 JSD_PUBLIC_API(void)
 438 JSD_SetSourceDirty(JSDContext* jsdc, JSDSourceText* jsdsrc, JSBool dirty)
 439 {
 440     JSD_ASSERT_VALID_CONTEXT(jsdc);
 441     JSD_ASSERT_VALID_SOURCE_TEXT(jsdsrc);
 442     jsd_SetSourceDirty(jsdc, jsdsrc, dirty);
 443 }
 444
 445 JSD_PUBLIC_API(uintN)
 446 JSD_GetSourceAlterCount(JSDContext* jsdc, JSDSourceText* jsdsrc)
 447 {
 448     JSD_ASSERT_VALID_CONTEXT(jsdc);
 449     JSD_ASSERT_VALID_SOURCE_TEXT(jsdsrc);
 450     return jsd_GetSourceAlterCount(jsdc, jsdsrc);
 451 }
 452
 453 JSD_PUBLIC_API(uintN)
 454 JSD_IncrementSourceAlterCount(JSDContext* jsdc, JSDSourceText* jsdsrc)
 455 {
 456     JSD_ASSERT_VALID_CONTEXT(jsdc);
 457     JSD_ASSERT_VALID_SOURCE_TEXT(jsdsrc);
 458     return jsd_IncrementSourceAlterCount(jsdc, jsdsrc);
 459 }
 460
 461 JSD_PUBLIC_API(void)
 462 JSD_DestroyAllSources( JSDContext* jsdc )
 463 {
 464     JSD_ASSERT_VALID_CONTEXT(jsdc);
 465     jsd_DestroyAllSources(jsdc);
 466 }
 467
 468 JSD_PUBLIC_API(JSDSourceText*)
 469 JSD_NewSourceText(JSDContext* jsdc, const char* url)
 470 {
 471     JSD_ASSERT_VALID_CONTEXT(jsdc);
 472     JS_ASSERT(url);
 473     return jsd_NewSourceText(jsdc, url);
 474 }
 475
 476 JSD_PUBLIC_API(JSDSourceText*)
 477 JSD_AppendSourceText(JSDContext* jsdc,
 478                      JSDSourceText* jsdsrc,
 479                      const char* text,       /* *not* zero terminated */
 480                      size_t length,
 481                      JSDSourceStatus status)
 482 {
 483     JSD_ASSERT_VALID_CONTEXT(jsdc);
 484     JSD_ASSERT_VALID_SOURCE_TEXT(jsdsrc);
 485     return jsd_AppendSourceText(jsdc, jsdsrc, text, length, status);
 486 }
 487
 488 extern JSD_PUBLIC_API(JSDSourceText*)
 489 JSD_AppendUCSourceText(JSDContext*     jsdc,
 490                        JSDSourceText*  jsdsrc,
 491                        const jschar*   text,       /* *not* zero terminated */
 492                        size_t          length,
 493                        JSDSourceStatus status)
 494 {
 495     JSD_ASSERT_VALID_CONTEXT(jsdc);
 496     JSD_ASSERT_VALID_SOURCE_TEXT(jsdsrc);
 497     return jsd_AppendUCSourceText(jsdc, jsdsrc, text, length, status);
 498 }
 499
 500 JSD_PUBLIC_API(JSBool)
 501 JSD_AddFullSourceText(JSDContext* jsdc,
 502                       const char* text,       /* *not* zero terminated */
 503                       size_t      length,
 504                       const char* url)
 505 {
 506     JSD_ASSERT_VALID_CONTEXT(jsdc);
 507     JS_ASSERT(url);
 508     return jsd_AddFullSourceText(jsdc, text, length, url);
 509 }
 510
 511 /***************************************************************************/
 512 /* Execution/Interrupt Hook functions */
 513
 514 JSD_PUBLIC_API(JSBool)
 515 JSD_SetExecutionHook(JSDContext*           jsdc,
 516                      JSDScript*            jsdscript,
 517                      jsuword              pc,
 518                      JSD_ExecutionHookProc hook,
 519                      void*                 callerdata)
 520 {
 521     JSD_ASSERT_VALID_CONTEXT(jsdc);
 522     JSD_ASSERT_VALID_SCRIPT(jsdscript);
 523     return jsd_SetExecutionHook(jsdc, jsdscript, pc, hook, callerdata);
 524 }
 525
 526 JSD_PUBLIC_API(JSBool)
 527 JSD_ClearExecutionHook(JSDContext*           jsdc,
 528                        JSDScript*            jsdscript,
 529                        jsuword              pc)
 530 {
 531     JSD_ASSERT_VALID_CONTEXT(jsdc);
 532     JSD_ASSERT_VALID_SCRIPT(jsdscript);
 533     return jsd_ClearExecutionHook(jsdc, jsdscript, pc);
 534 }
 535
 536 JSD_PUBLIC_API(JSBool)
 537 JSD_ClearAllExecutionHooksForScript(JSDContext* jsdc, JSDScript* jsdscript)
 538 {
 539     JSD_ASSERT_VALID_CONTEXT(jsdc);
 540     JSD_ASSERT_VALID_SCRIPT(jsdscript);
 541     return jsd_ClearAllExecutionHooksForScript(jsdc, jsdscript);
 542 }
 543
 544 JSD_PUBLIC_API(JSBool)
 545 JSD_ClearAllExecutionHooks(JSDContext* jsdc)
 546 {
 547     JSD_ASSERT_VALID_CONTEXT(jsdc);
 548     return jsd_ClearAllExecutionHooks(jsdc);
 549 }
 550
 551 JSD_PUBLIC_API(JSBool)
 552 JSD_SetInterruptHook(JSDContext*           jsdc,
 553                      JSD_ExecutionHookProc hook,
 554                      void*                 callerdata)
 555 {
 556     JSD_ASSERT_VALID_CONTEXT(jsdc);
 557     return jsd_SetInterruptHook(jsdc, hook, callerdata);
 558 }
 559
 560 JSD_PUBLIC_API(JSBool)
 561 JSD_ClearInterruptHook(JSDContext* jsdc)
 562 {
 563     JSD_ASSERT_VALID_CONTEXT(jsdc);
 564     return jsd_ClearInterruptHook(jsdc);
 565 }
 566
 567 JSD_PUBLIC_API(JSBool)
 568 JSD_SetDebugBreakHook(JSDContext*           jsdc,
 569                       JSD_ExecutionHookProc hook,
 570                       void*                 callerdata)
 571 {
 572     JSD_ASSERT_VALID_CONTEXT(jsdc);
 573     return jsd_SetDebugBreakHook(jsdc, hook, callerdata);
 574 }
 575
 576 JSD_PUBLIC_API(JSBool)
 577 JSD_ClearDebugBreakHook(JSDContext* jsdc)
 578 {
 579     JSD_ASSERT_VALID_CONTEXT(jsdc);
 580     return jsd_ClearDebugBreakHook(jsdc);
 581 }
 582
 583 JSD_PUBLIC_API(JSBool)
 584 JSD_SetDebuggerHook(JSDContext*           jsdc,
 585                     JSD_ExecutionHookProc hook,
 586                     void*                 callerdata)
 587 {
 588     JSD_ASSERT_VALID_CONTEXT(jsdc);
 589     return jsd_SetDebuggerHook(jsdc, hook, callerdata);
 590 }
 591
 592 JSD_PUBLIC_API(JSBool)
 593 JSD_ClearDebuggerHook(JSDContext* jsdc)
 594 {
 595     JSD_ASSERT_VALID_CONTEXT(jsdc);
 596     return jsd_ClearDebuggerHook(jsdc);
 597 }
 598
 599 JSD_PUBLIC_API(JSBool)
 600 JSD_SetThrowHook(JSDContext*           jsdc,
 601                  JSD_ExecutionHookProc hook,
 602                  void*                 callerdata)
 603 {
 604     JSD_ASSERT_VALID_CONTEXT(jsdc);
 605     return jsd_SetThrowHook(jsdc, hook, callerdata);
 606 }
 607
 608 JSD_PUBLIC_API(JSBool)
 609 JSD_ClearThrowHook(JSDContext* jsdc)
 610 {
 611     JSD_ASSERT_VALID_CONTEXT(jsdc);
 612     return jsd_ClearThrowHook(jsdc);
 613 }
 614
 615 JSD_PUBLIC_API(JSBool)
 616 JSD_SetTopLevelHook(JSDContext*      jsdc,
 617                     JSD_CallHookProc hook,
 618                     void*            callerdata)
 619 {
 620     JSD_ASSERT_VALID_CONTEXT(jsdc);
 621     return jsd_SetTopLevelHook(jsdc, hook, callerdata);
 622 }
 623
 624 JSD_PUBLIC_API(JSBool)
 625 JSD_ClearTopLevelHook(JSDContext* jsdc)
 626 {
 627     JSD_ASSERT_VALID_CONTEXT(jsdc);
 628     return jsd_ClearTopLevelHook(jsdc);
 629 }
 630
 631 JSD_PUBLIC_API(JSBool)
 632 JSD_SetFunctionHook(JSDContext*      jsdc,
 633                     JSD_CallHookProc hook,
 634                     void*            callerdata)
 635 {
 636     JSD_ASSERT_VALID_CONTEXT(jsdc);
 637     return jsd_SetFunctionHook(jsdc, hook, callerdata);
 638 }
 639
 640 JSD_PUBLIC_API(JSBool)
 641 JSD_ClearFunctionHook(JSDContext* jsdc)
 642 {
 643     JSD_ASSERT_VALID_CONTEXT(jsdc);
 644     return jsd_ClearFunctionHook(jsdc);
 645 }
 646
 647 /***************************************************************************/
 648 /* Stack Frame functions */
 649
 650 JSD_PUBLIC_API(uintN)
 651 JSD_GetCountOfStackFrames(JSDContext* jsdc, JSDThreadState* jsdthreadstate)
 652 {
 653     JSD_ASSERT_VALID_CONTEXT(jsdc);
 654     return jsd_GetCountOfStackFrames(jsdc, jsdthreadstate);
 655 }
 656
 657 JSD_PUBLIC_API(JSDStackFrameInfo*)
 658 JSD_GetStackFrame(JSDContext* jsdc, JSDThreadState* jsdthreadstate)
 659 {
 660     JSD_ASSERT_VALID_CONTEXT(jsdc);
 661     return jsd_GetStackFrame(jsdc, jsdthreadstate);
 662 }
 663
 664 JSD_PUBLIC_API(JSContext*)
 665 JSD_GetJSContext(JSDContext* jsdc, JSDThreadState* jsdthreadstate)
 666 {
 667     JSD_ASSERT_VALID_CONTEXT(jsdc);
 668     return jsd_GetJSContext(jsdc, jsdthreadstate);
 669 }
 670
 671 JSD_PUBLIC_API(JSDStackFrameInfo*)
 672 JSD_GetCallingStackFrame(JSDContext* jsdc,
 673                          JSDThreadState* jsdthreadstate,
 674                          JSDStackFrameInfo* jsdframe)
 675 {
 676     JSD_ASSERT_VALID_CONTEXT(jsdc);
 677     return jsd_GetCallingStackFrame(jsdc, jsdthreadstate, jsdframe);
 678 }
 679
 680 JSD_PUBLIC_API(JSDScript*)
 681 JSD_GetScriptForStackFrame(JSDContext* jsdc,
 682                            JSDThreadState* jsdthreadstate,
 683                            JSDStackFrameInfo* jsdframe)
 684 {
 685     JSD_ASSERT_VALID_CONTEXT(jsdc);
 686     return jsd_GetScriptForStackFrame(jsdc, jsdthreadstate, jsdframe);
 687 }
 688
 689 JSD_PUBLIC_API(jsuword)
 690 JSD_GetPCForStackFrame(JSDContext* jsdc,
 691                        JSDThreadState* jsdthreadstate,
 692                        JSDStackFrameInfo* jsdframe)
 693 {
 694     JSD_ASSERT_VALID_CONTEXT(jsdc);
 695     return jsd_GetPCForStackFrame(jsdc, jsdthreadstate, jsdframe);
 696 }
 697
 698 JSD_PUBLIC_API(JSDValue*)
 699 JSD_GetCallObjectForStackFrame(JSDContext* jsdc,
 700                                JSDThreadState* jsdthreadstate,
 701                                JSDStackFrameInfo* jsdframe)
 702 {
 703     JSD_ASSERT_VALID_CONTEXT(jsdc);
 704     return jsd_GetCallObjectForStackFrame(jsdc, jsdthreadstate, jsdframe);
 705 }
 706
 707 JSD_PUBLIC_API(JSDValue*)
 708 JSD_GetScopeChainForStackFrame(JSDContext* jsdc,
 709                                JSDThreadState* jsdthreadstate,
 710                                JSDStackFrameInfo* jsdframe)
 711 {
 712     JSD_ASSERT_VALID_CONTEXT(jsdc);
 713     return jsd_GetScopeChainForStackFrame(jsdc, jsdthreadstate, jsdframe);
 714 }
 715
 716 JSD_PUBLIC_API(JSDValue*)
 717 JSD_GetThisForStackFrame(JSDContext* jsdc,
 718                          JSDThreadState* jsdthreadstate,
 719                          JSDStackFrameInfo* jsdframe)
 720 {
 721     JSD_ASSERT_VALID_CONTEXT(jsdc);
 722     return jsd_GetThisForStackFrame(jsdc, jsdthreadstate, jsdframe);
 723 }
 724
 725 JSD_PUBLIC_API(const char*)
 726 JSD_GetNameForStackFrame(JSDContext* jsdc,
 727                          JSDThreadState* jsdthreadstate,
 728                          JSDStackFrameInfo* jsdframe)
 729 {
 730     JSD_ASSERT_VALID_CONTEXT(jsdc);
 731     return jsd_GetNameForStackFrame(jsdc, jsdthreadstate, jsdframe);
 732 }
 733
 734 JSD_PUBLIC_API(JSBool)
 735 JSD_IsStackFrameNative(JSDContext* jsdc,
 736                        JSDThreadState* jsdthreadstate,
 737                        JSDStackFrameInfo* jsdframe)
 738 {
 739     JSD_ASSERT_VALID_CONTEXT(jsdc);
 740     return jsd_IsStackFrameNative(jsdc, jsdthreadstate, jsdframe);
 741 }
 742
 743 JSD_PUBLIC_API(JSBool)
 744 JSD_IsStackFrameDebugger(JSDContext* jsdc,
 745                          JSDThreadState* jsdthreadstate,
 746                          JSDStackFrameInfo* jsdframe)
 747 {
 748     JSD_ASSERT_VALID_CONTEXT(jsdc);
 749     return jsd_IsStackFrameDebugger(jsdc, jsdthreadstate, jsdframe);
 750 }
 751
 752 JSD_PUBLIC_API(JSBool)
 753 JSD_IsStackFrameConstructing(JSDContext* jsdc,
 754                              JSDThreadState* jsdthreadstate,
 755                              JSDStackFrameInfo* jsdframe)
 756 {
 757     JSD_ASSERT_VALID_CONTEXT(jsdc);
 758     return jsd_IsStackFrameConstructing(jsdc, jsdthreadstate, jsdframe);
 759 }
 760
 761 JSD_PUBLIC_API(JSBool)
 762 JSD_EvaluateUCScriptInStackFrame(JSDContext* jsdc,
 763                                  JSDThreadState* jsdthreadstate,
 764                                  JSDStackFrameInfo* jsdframe,
 765                                  const jschar *bytes, uintN length,
 766                                  const char *filename, uintN lineno, jsval *rval)
 767 {
 768     JSD_ASSERT_VALID_CONTEXT(jsdc);
 769     JS_ASSERT(bytes);
 770     JS_ASSERT(length);
 771     JS_ASSERT(filename);
 772     JS_ASSERT(rval);
 773
 774     return jsd_EvaluateUCScriptInStackFrame(jsdc, jsdthreadstate,jsdframe,
 775                                             bytes, length, filename, lineno,
 776                                              JS_TRUE, rval);
 777 }
 778
 779 JSD_PUBLIC_API(JSBool)
 780 JSD_AttemptUCScriptInStackFrame(JSDContext* jsdc,
 781                                 JSDThreadState* jsdthreadstate,
 782                                 JSDStackFrameInfo* jsdframe,
 783                                 const jschar *bytes, uintN length,
 784                                 const char *filename, uintN lineno,
 785                                 jsval *rval)
 786 {
 787     JSD_ASSERT_VALID_CONTEXT(jsdc);
 788     JS_ASSERT(bytes);
 789     JS_ASSERT(length);
 790     JS_ASSERT(filename);
 791     JS_ASSERT(rval);
 792
 793     return jsd_EvaluateUCScriptInStackFrame(jsdc, jsdthreadstate,jsdframe,
 794                                             bytes, length, filename, lineno,
 795                                             JS_FALSE, rval);
 796 }
 797
 798 JSD_PUBLIC_API(JSBool)
 799 JSD_EvaluateScriptInStackFrame(JSDContext* jsdc,
 800                                JSDThreadState* jsdthreadstate,
 801                                JSDStackFrameInfo* jsdframe,
 802                                const char *bytes, uintN length,
 803                                const char *filename, uintN lineno, jsval *rval)
 804 {
 805     JSD_ASSERT_VALID_CONTEXT(jsdc);
 806     JS_ASSERT(bytes);
 807     JS_ASSERT(length);
 808     JS_ASSERT(filename);
 809     JS_ASSERT(rval);
 810
 811     return jsd_EvaluateScriptInStackFrame(jsdc, jsdthreadstate,jsdframe,
 812                                           bytes, length,
 813                                           filename, lineno, JS_TRUE, rval);
 814 }
 815
 816 JSD_PUBLIC_API(JSBool)
 817 JSD_AttemptScriptInStackFrame(JSDContext* jsdc,
 818                               JSDThreadState* jsdthreadstate,
 819                               JSDStackFrameInfo* jsdframe,
 820                               const char *bytes, uintN length,
 821                               const char *filename, uintN lineno, jsval *rval)
 822 {
 823     JSD_ASSERT_VALID_CONTEXT(jsdc);
 824     JS_ASSERT(bytes);
 825     JS_ASSERT(length);
 826     JS_ASSERT(filename);
 827     JS_ASSERT(rval);
 828
 829     return jsd_EvaluateScriptInStackFrame(jsdc, jsdthreadstate,jsdframe,
 830                                           bytes, length,
 831                                           filename, lineno, JS_FALSE, rval);
 832 }
 833
 834 JSD_PUBLIC_API(JSString*)
 835 JSD_ValToStringInStackFrame(JSDContext* jsdc,
 836                             JSDThreadState* jsdthreadstate,
 837                             JSDStackFrameInfo* jsdframe,
 838                             jsval val)
 839 {
 840     JSD_ASSERT_VALID_CONTEXT(jsdc);
 841     return jsd_ValToStringInStackFrame(jsdc, jsdthreadstate, jsdframe, val);
 842 }
 843
 844 JSD_PUBLIC_API(JSDValue*)
 845 JSD_GetException(JSDContext* jsdc, JSDThreadState* jsdthreadstate)
 846 {
 847     JSD_ASSERT_VALID_CONTEXT(jsdc);
 848     return jsd_GetException(jsdc, jsdthreadstate);
 849 }
 850
 851 extern JSD_PUBLIC_API(JSBool)
 852 JSD_SetException(JSDContext* jsdc, JSDThreadState* jsdthreadstate,
 853                  JSDValue* jsdval)
 854 {
 855     JSD_ASSERT_VALID_CONTEXT(jsdc);
 856     return jsd_SetException(jsdc, jsdthreadstate, jsdval);
 857 }
 858
 859 /***************************************************************************/
 860
 861 JSD_PUBLIC_API(JSBool)
 862 JSD_SetErrorReporter(JSDContext*       jsdc,
 863                      JSD_ErrorReporter reporter,
 864                      void*             callerdata)
 865 {
 866     JSD_ASSERT_VALID_CONTEXT(jsdc);
 867     return jsd_SetErrorReporter(jsdc, reporter, callerdata);
 868 }
 869
 870 JSD_PUBLIC_API(JSBool)
 871 JSD_GetErrorReporter(JSDContext*        jsdc,
 872                      JSD_ErrorReporter* reporter,
 873                      void**             callerdata)
 874 {
 875     JSD_ASSERT_VALID_CONTEXT(jsdc);
 876     return jsd_GetErrorReporter(jsdc, reporter, callerdata);
 877 }
 878
 879 /***************************************************************************/
 880
 881 JSD_PUBLIC_API(JSBool)
 882 JSD_IsLockingAndThreadIdSupported()
 883 {
 884 #ifdef JSD_THREADSAFE
 885     return JS_TRUE;
 886 #else
 887     return JS_FALSE;
 888 #endif
 889 }
 890
 891 JSD_PUBLIC_API(void*)
 892 JSD_CreateLock()
 893 {
 894 #ifdef JSD_THREADSAFE
 895     return jsd_CreateLock();
 896 #else
 897     return (void*)1;
 898 #endif
 899 }
 900
 901 JSD_PUBLIC_API(void)
 902 JSD_Lock(void* lock)
 903 {
 904 #ifdef JSD_THREADSAFE
 905     jsd_Lock(lock);
 906 #endif
 907 }
 908
 909 JSD_PUBLIC_API(void)
 910 JSD_Unlock(void* lock)
 911 {
 912 #ifdef JSD_THREADSAFE
 913     jsd_Unlock(lock);
 914 #endif
 915 }
 916
 917 JSD_PUBLIC_API(JSBool)
 918 JSD_IsLocked(void* lock)
 919 {
 920 #if defined(JSD_THREADSAFE) && defined(DEBUG)
 921     return jsd_IsLocked(lock);
 922 #else
 923     return JS_TRUE;
 924 #endif
 925 }
 926
 927 JSD_PUBLIC_API(JSBool)
 928 JSD_IsUnlocked(void* lock)
 929 {
 930 #if defined(JSD_THREADSAFE) && defined(DEBUG)
 931     return ! jsd_IsLocked(lock);
 932 #else
 933     return JS_TRUE;
 934 #endif
 935 }
 936
 937 JSD_PUBLIC_API(void*)
 938 JSD_CurrentThread()
 939 {
 940     return JSD_CURRENT_THREAD();
 941 }
 942
 943 /***************************************************************************/
 944 /* Value and Property Functions */
 945
 946 JSD_PUBLIC_API(JSDValue*)
 947 JSD_NewValue(JSDContext* jsdc, jsval val)
 948 {
 949     JSD_ASSERT_VALID_CONTEXT(jsdc);
 950     return jsd_NewValue(jsdc, val);
 951 }
 952
 953 JSD_PUBLIC_API(void)
 954 JSD_DropValue(JSDContext* jsdc, JSDValue* jsdval)
 955 {
 956     JSD_ASSERT_VALID_CONTEXT(jsdc);
 957     JSD_ASSERT_VALID_VALUE(jsdval);
 958     jsd_DropValue(jsdc, jsdval);
 959 }
 960
 961 JSD_PUBLIC_API(jsval)
 962 JSD_GetValueWrappedJSVal(JSDContext* jsdc, JSDValue* jsdval)
 963 {
 964     JSD_ASSERT_VALID_CONTEXT(jsdc);
 965     JSD_ASSERT_VALID_VALUE(jsdval);
 966     return jsd_GetValueWrappedJSVal(jsdc, jsdval);
 967 }
 968
 969 JSD_PUBLIC_API(void)
 970 JSD_RefreshValue(JSDContext* jsdc, JSDValue* jsdval)
 971 {
 972     JSD_ASSERT_VALID_CONTEXT(jsdc);
 973     JSD_ASSERT_VALID_VALUE(jsdval);
 974     jsd_RefreshValue(jsdc, jsdval);
 975 }
 976
 977 /**************************************************/
 978
 979 JSD_PUBLIC_API(JSBool)
 980 JSD_IsValueObject(JSDContext* jsdc, JSDValue* jsdval)
 981 {
 982     JSD_ASSERT_VALID_CONTEXT(jsdc);
 983     JSD_ASSERT_VALID_VALUE(jsdval);
 984     return jsd_IsValueObject(jsdc, jsdval);
 985 }
 986
 987 JSD_PUBLIC_API(JSBool)
 988 JSD_IsValueNumber(JSDContext* jsdc, JSDValue* jsdval)
 989 {
 990     JSD_ASSERT_VALID_CONTEXT(jsdc);
 991     JSD_ASSERT_VALID_VALUE(jsdval);
 992     return jsd_IsValueNumber(jsdc, jsdval);
 993 }
 994
 995 JSD_PUBLIC_API(JSBool)
 996 JSD_IsValueInt(JSDContext* jsdc, JSDValue* jsdval)
 997 {
 998     JSD_ASSERT_VALID_CONTEXT(jsdc);
 999     JSD_ASSERT_VALID_VALUE(jsdval);
1000     return jsd_IsValueInt(jsdc, jsdval);
1001 }
1002
1003 JSD_PUBLIC_API(JSBool)
1004 JSD_IsValueDouble(JSDContext* jsdc, JSDValue* jsdval)
1005 {
1006     JSD_ASSERT_VALID_CONTEXT(jsdc);
1007     JSD_ASSERT_VALID_VALUE(jsdval);
1008     return jsd_IsValueDouble(jsdc, jsdval);
1009 }
1010
1011 JSD_PUBLIC_API(JSBool)
1012 JSD_IsValueString(JSDContext* jsdc, JSDValue* jsdval)
1013 {
1014     JSD_ASSERT_VALID_CONTEXT(jsdc);
1015     JSD_ASSERT_VALID_VALUE(jsdval);
1016     return jsd_IsValueString(jsdc, jsdval);
1017 }
1018
1019 JSD_PUBLIC_API(JSBool)
1020 JSD_IsValueBoolean(JSDContext* jsdc, JSDValue* jsdval)
1021 {
1022     JSD_ASSERT_VALID_CONTEXT(jsdc);
1023     JSD_ASSERT_VALID_VALUE(jsdval);
1024     return jsd_IsValueBoolean(jsdc, jsdval);
1025 }
1026
1027 JSD_PUBLIC_API(JSBool)
1028 JSD_IsValueNull(JSDContext* jsdc, JSDValue* jsdval)
1029 {
1030     JSD_ASSERT_VALID_CONTEXT(jsdc);
1031     JSD_ASSERT_VALID_VALUE(jsdval);
1032     return jsd_IsValueNull(jsdc, jsdval);
1033 }
1034
1035 JSD_PUBLIC_API(JSBool)
1036 JSD_IsValueVoid(JSDContext* jsdc, JSDValue* jsdval)
1037 {
1038     JSD_ASSERT_VALID_CONTEXT(jsdc);
1039     JSD_ASSERT_VALID_VALUE(jsdval);
1040     return jsd_IsValueVoid(jsdc, jsdval);
1041 }
1042
1043 JSD_PUBLIC_API(JSBool)
1044 JSD_IsValuePrimitive(JSDContext* jsdc, JSDValue* jsdval)
1045 {
1046     JSD_ASSERT_VALID_CONTEXT(jsdc);
1047     JSD_ASSERT_VALID_VALUE(jsdval);
1048     return jsd_IsValuePrimitive(jsdc, jsdval);
1049 }
1050
1051 JSD_PUBLIC_API(JSBool)
1052 JSD_IsValueFunction(JSDContext* jsdc, JSDValue* jsdval)
1053 {
1054     JSD_ASSERT_VALID_CONTEXT(jsdc);
1055     JSD_ASSERT_VALID_VALUE(jsdval);
1056     return jsd_IsValueFunction(jsdc, jsdval);
1057 }
1058
1059 JSD_PUBLIC_API(JSBool)
1060 JSD_IsValueNative(JSDContext* jsdc, JSDValue* jsdval)
1061 {
1062     JSD_ASSERT_VALID_CONTEXT(jsdc);
1063     JSD_ASSERT_VALID_VALUE(jsdval);
1064     return jsd_IsValueNative(jsdc, jsdval);
1065 }
1066
1067 /**************************************************/
1068
1069 JSD_PUBLIC_API(JSBool)
1070 JSD_GetValueBoolean(JSDContext* jsdc, JSDValue* jsdval)
1071 {
1072     JSD_ASSERT_VALID_CONTEXT(jsdc);
1073     JSD_ASSERT_VALID_VALUE(jsdval);
1074     return jsd_GetValueBoolean(jsdc, jsdval);
1075 }
1076
1077 JSD_PUBLIC_API(int32)
1078 JSD_GetValueInt(JSDContext* jsdc, JSDValue* jsdval)
1079 {
1080     JSD_ASSERT_VALID_CONTEXT(jsdc);
1081     JSD_ASSERT_VALID_VALUE(jsdval);
1082     return jsd_GetValueInt(jsdc, jsdval);
1083 }
1084
1085 JSD_PUBLIC_API(jsdouble*)
1086 JSD_GetValueDouble(JSDContext* jsdc, JSDValue* jsdval)
1087 {
1088     JSD_ASSERT_VALID_CONTEXT(jsdc);
1089     JSD_ASSERT_VALID_VALUE(jsdval);
1090     return jsd_GetValueDouble(jsdc, jsdval);
1091 }
1092
1093 JSD_PUBLIC_API(JSString*)
1094 JSD_GetValueString(JSDContext* jsdc, JSDValue* jsdval)
1095 {
1096     JSD_ASSERT_VALID_CONTEXT(jsdc);
1097     JSD_ASSERT_VALID_VALUE(jsdval);
1098     return jsd_GetValueString(jsdc, jsdval);
1099 }
1100
1101 JSD_PUBLIC_API(const char*)
1102 JSD_GetValueFunctionName(JSDContext* jsdc, JSDValue* jsdval)
1103 {
1104     JSD_ASSERT_VALID_CONTEXT(jsdc);
1105     JSD_ASSERT_VALID_VALUE(jsdval);
1106     return jsd_GetValueFunctionName(jsdc, jsdval);
1107 }
1108
1109 /**************************************************/
1110
1111 JSD_PUBLIC_API(uintN)
1112 JSD_GetCountOfProperties(JSDContext* jsdc, JSDValue* jsdval)
1113 {
1114     JSD_ASSERT_VALID_CONTEXT(jsdc);
1115     JSD_ASSERT_VALID_VALUE(jsdval);
1116     return jsd_GetCountOfProperties(jsdc, jsdval);
1117 }
1118
1119 JSD_PUBLIC_API(JSDProperty*)
1120 JSD_IterateProperties(JSDContext* jsdc, JSDValue* jsdval, JSDProperty **iterp)
1121 {
1122     JSD_ASSERT_VALID_CONTEXT(jsdc);
1123     JSD_ASSERT_VALID_VALUE(jsdval);
1124     JS_ASSERT(iterp);
1125     return jsd_IterateProperties(jsdc, jsdval, iterp);
1126 }
1127
1128 JSD_PUBLIC_API(JSDProperty*)
1129 JSD_GetValueProperty(JSDContext* jsdc, JSDValue* jsdval, JSString* name)
1130 {
1131     JSD_ASSERT_VALID_CONTEXT(jsdc);
1132     JSD_ASSERT_VALID_VALUE(jsdval);
1133     JS_ASSERT(name);
1134     return jsd_GetValueProperty(jsdc, jsdval, name);
1135 }
1136
1137 JSD_PUBLIC_API(JSDValue*)
1138 JSD_GetValuePrototype(JSDContext* jsdc, JSDValue* jsdval)
1139 {
1140     JSD_ASSERT_VALID_CONTEXT(jsdc);
1141     JSD_ASSERT_VALID_VALUE(jsdval);
1142     return jsd_GetValuePrototype(jsdc, jsdval);
1143 }
1144
1145 JSD_PUBLIC_API(JSDValue*)
1146 JSD_GetValueParent(JSDContext* jsdc, JSDValue* jsdval)
1147 {
1148     JSD_ASSERT_VALID_CONTEXT(jsdc);
1149     JSD_ASSERT_VALID_VALUE(jsdval);
1150     return jsd_GetValueParent(jsdc, jsdval);
1151 }
1152
1153 JSD_PUBLIC_API(JSDValue*)
1154 JSD_GetValueConstructor(JSDContext* jsdc, JSDValue* jsdval)
1155 {
1156     JSD_ASSERT_VALID_CONTEXT(jsdc);
1157     JSD_ASSERT_VALID_VALUE(jsdval);
1158     return jsd_GetValueConstructor(jsdc, jsdval);
1159 }
1160
1161 JSD_PUBLIC_API(const char*)
1162 JSD_GetValueClassName(JSDContext* jsdc, JSDValue* jsdval)
1163 {
1164     JSD_ASSERT_VALID_CONTEXT(jsdc);
1165     JSD_ASSERT_VALID_VALUE(jsdval);
1166     return jsd_GetValueClassName(jsdc, jsdval);
1167 }
1168
1169 /**************************************************/
1170
1171 JSD_PUBLIC_API(void)
1172 JSD_DropProperty(JSDContext* jsdc, JSDProperty* jsdprop)
1173 {
1174     JSD_ASSERT_VALID_CONTEXT(jsdc);
1175     JSD_ASSERT_VALID_PROPERTY(jsdprop);
1176     jsd_DropProperty(jsdc, jsdprop);
1177 }
1178
1179
1180 JSD_PUBLIC_API(JSDValue*)
1181 JSD_GetPropertyName(JSDContext* jsdc, JSDProperty* jsdprop)
1182 {
1183     JSD_ASSERT_VALID_CONTEXT(jsdc);
1184     JSD_ASSERT_VALID_PROPERTY(jsdprop);
1185     return jsd_GetPropertyName(jsdc, jsdprop);
1186 }
1187
1188 JSD_PUBLIC_API(JSDValue*)
1189 JSD_GetPropertyValue(JSDContext* jsdc, JSDProperty* jsdprop)
1190 {
1191     JSD_ASSERT_VALID_CONTEXT(jsdc);
1192     JSD_ASSERT_VALID_PROPERTY(jsdprop);
1193     return jsd_GetPropertyValue(jsdc, jsdprop);
1194 }
1195
1196 JSD_PUBLIC_API(JSDValue*)
1197 JSD_GetPropertyAlias(JSDContext* jsdc, JSDProperty* jsdprop)
1198 {
1199     JSD_ASSERT_VALID_CONTEXT(jsdc);
1200     JSD_ASSERT_VALID_PROPERTY(jsdprop);
1201     return jsd_GetPropertyAlias(jsdc, jsdprop);
1202 }
1203
1204 JSD_PUBLIC_API(uintN)
1205 JSD_GetPropertyFlags(JSDContext* jsdc, JSDProperty* jsdprop)
1206 {
1207     JSD_ASSERT_VALID_CONTEXT(jsdc);
1208     JSD_ASSERT_VALID_PROPERTY(jsdprop);
1209     return jsd_GetPropertyFlags(jsdc, jsdprop);
1210 }
1211
1212 JSD_PUBLIC_API(uintN)
1213 JSD_GetPropertyVarArgSlot(JSDContext* jsdc, JSDProperty* jsdprop)
1214 {
1215     JSD_ASSERT_VALID_CONTEXT(jsdc);
1216     JSD_ASSERT_VALID_PROPERTY(jsdprop);
1217     return jsd_GetPropertyVarArgSlot(jsdc, jsdprop);
1218 }
1219
1220 /**************************************************/
1221 /* Object Functions */
1222
1223 JSD_PUBLIC_API(void)
1224 JSD_LockObjectSubsystem(JSDContext* jsdc)
1225 {
1226     JSD_ASSERT_VALID_CONTEXT(jsdc);
1227     JSD_LOCK_OBJECTS(jsdc);
1228 }
1229
1230 JSD_PUBLIC_API(void)
1231 JSD_UnlockObjectSubsystem(JSDContext* jsdc)
1232 {
1233     JSD_ASSERT_VALID_CONTEXT(jsdc);
1234     JSD_UNLOCK_OBJECTS(jsdc);
1235 }
1236
1237 JSD_PUBLIC_API(JSDObject*)
1238 JSD_IterateObjects(JSDContext* jsdc, JSDObject** iterp)
1239 {
1240     JSD_ASSERT_VALID_CONTEXT(jsdc);
1241     return jsd_IterateObjects(jsdc, iterp);
1242 }
1243
1244 JSD_PUBLIC_API(JSObject*)
1245 JSD_GetWrappedObject(JSDContext* jsdc, JSDObject* jsdobj)
1246 {
1247     JSD_ASSERT_VALID_CONTEXT(jsdc);
1248     JSD_ASSERT_VALID_OBJECT(jsdobj);
1249     return jsd_GetWrappedObject(jsdc, jsdobj);
1250
1251 }
1252
1253 JSD_PUBLIC_API(const char*)
1254 JSD_GetObjectNewURL(JSDContext* jsdc, JSDObject* jsdobj)
1255 {
1256     JSD_ASSERT_VALID_CONTEXT(jsdc);
1257     JSD_ASSERT_VALID_OBJECT(jsdobj);
1258     return jsd_GetObjectNewURL(jsdc, jsdobj);
1259 }
1260
1261 JSD_PUBLIC_API(uintN)
1262 JSD_GetObjectNewLineNumber(JSDContext* jsdc, JSDObject* jsdobj)
1263 {
1264     JSD_ASSERT_VALID_CONTEXT(jsdc);
1265     JSD_ASSERT_VALID_OBJECT(jsdobj);
1266     return jsd_GetObjectNewLineNumber(jsdc, jsdobj);
1267 }
1268
1269 JSD_PUBLIC_API(const char*)
1270 JSD_GetObjectConstructorURL(JSDContext* jsdc, JSDObject* jsdobj)
1271 {
1272     JSD_ASSERT_VALID_CONTEXT(jsdc);
1273     JSD_ASSERT_VALID_OBJECT(jsdobj);
1274     return jsd_GetObjectConstructorURL(jsdc, jsdobj);
1275 }
1276
1277 JSD_PUBLIC_API(uintN)
1278 JSD_GetObjectConstructorLineNumber(JSDContext* jsdc, JSDObject* jsdobj)
1279 {
1280     JSD_ASSERT_VALID_CONTEXT(jsdc);
1281     JSD_ASSERT_VALID_OBJECT(jsdobj);
1282     return jsd_GetObjectConstructorLineNumber(jsdc, jsdobj);
1283 }
1284
1285 JSD_PUBLIC_API(const char*)
1286 JSD_GetObjectConstructorName(JSDContext* jsdc, JSDObject* jsdobj)
1287 {
1288     JSD_ASSERT_VALID_CONTEXT(jsdc);
1289     JSD_ASSERT_VALID_OBJECT(jsdobj);
1290     return jsd_GetObjectConstructorName(jsdc, jsdobj);
1291 }
1292
1293 JSD_PUBLIC_API(JSDObject*)
1294 JSD_GetJSDObjectForJSObject(JSDContext* jsdc, JSObject* jsobj)
1295 {
1296     JSD_ASSERT_VALID_CONTEXT(jsdc);
1297     JS_ASSERT(jsobj);
1298     return jsd_GetJSDObjectForJSObject(jsdc, jsobj);
1299 }
1300
1301 JSD_PUBLIC_API(JSDObject*)
1302 JSD_GetObjectForValue(JSDContext* jsdc, JSDValue* jsdval)
1303 {
1304     JSD_ASSERT_VALID_CONTEXT(jsdc);
1305     JSD_ASSERT_VALID_VALUE(jsdval);
1306     return jsd_GetObjectForValue(jsdc, jsdval);
1307 }
1308
1309 JSD_PUBLIC_API(JSDValue*)
1310 JSD_GetValueForObject(JSDContext* jsdc, JSDObject* jsdobj)
1311 {
1312     JSD_ASSERT_VALID_CONTEXT(jsdc);
1313     JSD_ASSERT_VALID_OBJECT(jsdobj);
1314     return jsd_GetValueForObject(jsdc, jsdobj);
1315 }
1316
1317 /***************************************************************************/
1318 /* Livewire specific API */
1319 #ifdef LIVEWIRE
1320
1321 JSD_PUBLIC_API(LWDBGScript*)
1322 JSDLW_GetLWScript(JSDContext* jsdc, JSDScript* jsdscript)
1323 {
1324     JSD_ASSERT_VALID_CONTEXT(jsdc);
1325     JSD_ASSERT_VALID_SCRIPT(jsdscript);
1326     return jsdlw_GetLWScript(jsdc, jsdscript);
1327 }
1328
1329 JSD_PUBLIC_API(JSDSourceText*)
1330 JSDLW_PreLoadSource( JSDContext* jsdc, LWDBGApp* app,
1331                      const char* filename, JSBool clear )
1332 {
1333     JSD_ASSERT_VALID_CONTEXT(jsdc);
1334     JS_ASSERT(app);
1335     JS_ASSERT(filename);
1336     return jsdlw_PreLoadSource(jsdc, app, filename, clear);
1337 }
1338
1339 JSD_PUBLIC_API(JSDSourceText*)
1340 JSDLW_ForceLoadSource( JSDContext* jsdc, JSDSourceText* jsdsrc )
1341 {
1342     JSD_ASSERT_VALID_CONTEXT(jsdc);
1343     JSD_ASSERT_VALID_SOURCE_TEXT(jsdsrc);
1344     return jsdlw_ForceLoadSource(jsdc, jsdsrc);
1345 }
1346
1347 JSD_PUBLIC_API(JSBool)
1348 JSDLW_RawToProcessedLineNumber(JSDContext* jsdc, JSDScript* jsdscript,
1349                                uintN lineIn, uintN* lineOut)
1350 {
1351     JSD_ASSERT_VALID_CONTEXT(jsdc);
1352     JSD_ASSERT_VALID_SCRIPT(jsdscript);
1353     return jsdlw_RawToProcessedLineNumber(jsdc, jsdscript, lineIn, lineOut);
1354 }
1355
1356 JSD_PUBLIC_API(JSBool)
1357 JSDLW_ProcessedToRawLineNumber(JSDContext* jsdc, JSDScript* jsdscript,
1358                                uintN lineIn, uintN* lineOut)
1359 {
1360     JSD_ASSERT_VALID_CONTEXT(jsdc);
1361     JSD_ASSERT_VALID_SCRIPT(jsdscript);
1362     return jsdlw_ProcessedToRawLineNumber(jsdc, jsdscript, lineIn, lineOut);
1363 }
1364
1365 #endif
1366 /***************************************************************************/