LCOV - code coverage report
Current view: directory - js/jsd - jsdebug.c (source / functions) Found Hit Coverage
Test: app.info Lines: 564 116 20.6 %
Date: 2012-06-02 Functions: 155 34 21.9 %

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

Generated by: LCOV version 1.7