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