← Back to branch summary

~ubuntu-branches/ubuntu/precise/kompozer/precise

« back to all changes in this revision

Viewing changes to mozilla/js/jsd/jsd_xpc.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Yarusso
  • Date: 2007-08-27 01:11:03 UTC
  • Revision ID: james.westby@ubuntu.com-20070827011103-2jgf4s6532gqu2ka
Tags: upstream-0.7.10
Import upstream version 0.7.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/js/jsd/jsd_xpc.cpp
 
1
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 
2
 *
 
3
 * The contents of this file are subject to the Mozilla Public License
 
4
 * Version 1.1 (the "License"); you may not use this file except in
 
5
 * compliance with the License. You may obtain a copy of the License at
 
6
 * http://www.mozilla.org/MPL/ 
 
7
 * 
 
8
 * Software distributed under the License is distributed on an "AS IS" basis,
 
9
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 
10
 * for the specific language governing rights and limitations under the
 
11
 * License. 
 
12
 *
 
13
 * The Original Code is mozilla.org code
 
14
 * 
 
15
 * The Initial Developer of the Original Code is
 
16
 * Netscape Communications Corporation
 
17
 * Portions created by Netscape are
 
18
 * Copyright (C) 1998 Netscape Communications Corporation.
 
19
 *
 
20
 * Alternatively, the contents of this file may be used under the
 
21
 * terms of the GNU Public License (the "GPL"), in which case the
 
22
 * provisions of the GPL are applicable instead of those above.
 
23
 * If you wish to allow use of your version of this file only
 
24
 * under the terms of the GPL and not to allow others to use your
 
25
 * version of this file under the MPL, indicate your decision by
 
26
 * deleting the provisions above and replace them with the notice
 
27
 * and other provisions required by the GPL.  If you do not delete
 
28
 * the provisions above, a recipient may use your version of this
 
29
 * file under either the MPL or the GPL.
 
30
 *
 
31
 * Contributor(s):
 
32
 *   Robert Ginda, <rginda@netscape.com>
 
33
 *
 
34
 */
 
35
 
 
36
#include "jsd_xpc.h"
 
37
#include "jsdbgapi.h"
 
38
#include "jscntxt.h"
 
39
#include "jsfun.h"
 
40
 
 
41
#include "nsIXPConnect.h"
 
42
#include "nsIGenericFactory.h"
 
43
#include "nsIServiceManager.h"
 
44
#include "nsIScriptGlobalObject.h"
 
45
#include "nsIObserver.h"
 
46
#include "nsIObserverService.h"
 
47
#include "nsICategoryManager.h"
 
48
#include "nsIJSRuntimeService.h"
 
49
#include "nsIEventQueueService.h"
 
50
#include "nsMemory.h"
 
51
#include "jsdebug.h"
 
52
#include "nsReadableUtils.h"
 
53
#include "nsCRT.h"
 
54
 
 
55
/* XXX this stuff is used by NestEventLoop, a temporary hack to be refactored
 
56
 * later */
 
57
#include "nsWidgetsCID.h"
 
58
#include "nsIScriptContext.h"
 
59
#include "nsIAppShell.h"
 
60
#include "nsIJSContextStack.h"
 
61
 
 
62
/*
 
63
 * defining CAUTIOUS_SCRIPTHOOK makes jsds disable GC while calling out to the
 
64
 * script hook.  This was a hack to avoid some js engine problems that should
 
65
 * be fixed now (see Mozilla bug 77636).
 
66
 */
 
67
#undef CAUTIOUS_SCRIPTHOOK
 
68
 
 
69
#ifdef DEBUG_verbose
 
70
#   define DEBUG_COUNT(name, count)                                             \
 
71
        { if ((count % 10) == 0) printf (name ": %i\n", count); }
 
72
#   define DEBUG_CREATE(name, count) {count++; DEBUG_COUNT ("+++++ "name,count)}
 
73
#   define DEBUG_DESTROY(name, count) {count--; DEBUG_COUNT ("----- "name,count)}
 
74
#else
 
75
#   define DEBUG_CREATE(name, count) 
 
76
#   define DEBUG_DESTROY(name, count)
 
77
#endif
 
78
 
 
79
#define ASSERT_VALID_CONTEXT   { if (!mCx) return NS_ERROR_NOT_AVAILABLE; }
 
80
#define ASSERT_VALID_EPHEMERAL { if (!mValid) return NS_ERROR_NOT_AVAILABLE; }
 
81
 
 
82
#define JSDSERVICE_CID                               \
 
83
{ /* f1299dc2-1dd1-11b2-a347-ee6b7660e048 */         \
 
84
     0xf1299dc2,                                     \
 
85
     0x1dd1,                                         \
 
86
     0x11b2,                                         \
 
87
    {0xa3, 0x47, 0xee, 0x6b, 0x76, 0x60, 0xe0, 0x48} \
 
88
}
 
89
 
 
90
#define JSDASO_CID                                   \
 
91
{ /* 2fd6b7f6-eb8c-4f32-ad26-113f2c02d0fe */         \
 
92
     0x2fd6b7f6,                                     \
 
93
     0xeb8c,                                         \
 
94
     0x4f32,                                         \
 
95
    {0xad, 0x26, 0x11, 0x3f, 0x2c, 0x02, 0xd0, 0xfe} \
 
96
}
 
97
 
 
98
#define JSDS_MAJOR_VERSION 1
 
99
#define JSDS_MINOR_VERSION 2
 
100
 
 
101
#define NS_CATMAN_CTRID   "@mozilla.org/categorymanager;1"
 
102
#define NS_JSRT_CTRID     "@mozilla.org/js/xpc/RuntimeService;1"
 
103
 
 
104
#define AUTOREG_CATEGORY  "xpcom-autoregistration"
 
105
#define APPSTART_CATEGORY "app-startup"
 
106
#define JSD_AUTOREG_ENTRY "JSDebugger Startup Observer"
 
107
#define JSD_STARTUP_ENTRY "JSDebugger Startup Observer,service"
 
108
 
 
109
JS_STATIC_DLL_CALLBACK (JSBool)
 
110
jsds_GCCallbackProc (JSContext *cx, JSGCStatus status);
 
111
 
 
112
/*******************************************************************************
 
113
 * global vars
 
114
 ******************************************************************************/
 
115
 
 
116
const char implementationString[] = "Mozilla JavaScript Debugger Service";
 
117
static NS_DEFINE_CID(kAppShellCID, NS_APPSHELL_CID);
 
118
static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
 
119
 
 
120
const char jsdServiceCtrID[] = "@mozilla.org/js/jsd/debugger-service;1";
 
121
const char jsdASObserverCtrID[] = "@mozilla.org/js/jsd/app-start-observer;2";
 
122
 
 
123
#ifdef DEBUG_verbose
 
124
PRUint32 gScriptCount   = 0;
 
125
PRUint32 gValueCount    = 0;
 
126
PRUint32 gPropertyCount = 0;
 
127
PRUint32 gContextCount  = 0;
 
128
PRUint32 gFrameCount  = 0;
 
129
#endif
 
130
 
 
131
static jsdService   *gJsds       = 0;
 
132
static JSGCCallback  gLastGCProc = jsds_GCCallbackProc;
 
133
static JSGCStatus    gGCStatus   = JSGC_END;
 
134
 
 
135
static struct DeadScript {
 
136
    PRCList     links;
 
137
    JSDContext *jsdc;
 
138
    jsdIScript *script;
 
139
} *gDeadScripts = nsnull;
 
140
 
 
141
enum PatternType {
 
142
    ptIgnore     = 0U,
 
143
    ptStartsWith = 1U,
 
144
    ptEndsWith   = 2U,
 
145
    ptContains   = 3U,
 
146
    ptEquals     = 4U
 
147
};
 
148
 
 
149
static struct FilterRecord {
 
150
    PRCList      links;
 
151
    jsdIFilter  *filterObject;
 
152
    void        *glob;
 
153
    char        *urlPattern;    
 
154
    PRUint32     patternLength;
 
155
    PatternType  patternType;
 
156
    PRUint32     startLine;
 
157
    PRUint32     endLine;
 
158
} *gFilters = nsnull;
 
159
 
 
160
static struct LiveEphemeral *gLiveValues      = nsnull;
 
161
static struct LiveEphemeral *gLiveProperties  = nsnull;
 
162
static struct LiveEphemeral *gLiveContexts    = nsnull;
 
163
static struct LiveEphemeral *gLiveStackFrames = nsnull;
 
164
 
 
165
/*******************************************************************************
 
166
 * utility functions for ephemeral lists
 
167
 *******************************************************************************/
 
168
already_AddRefed<jsdIEphemeral>
 
169
jsds_FindEphemeral (LiveEphemeral **listHead, void *key)
 
170
{
 
171
    if (!*listHead)
 
172
        return nsnull;
 
173
    
 
174
    LiveEphemeral *lv_record = 
 
175
        NS_REINTERPRET_CAST (LiveEphemeral *,
 
176
                             PR_NEXT_LINK(&(*listHead)->links));
 
177
    do
 
178
    {
 
179
        if (lv_record->key == key)
 
180
        {
 
181
            NS_IF_ADDREF(lv_record->value);
 
182
            return lv_record->value;
 
183
        }
 
184
        lv_record = NS_REINTERPRET_CAST (LiveEphemeral *,
 
185
                                         PR_NEXT_LINK(&lv_record->links));
 
186
    }
 
187
    while (lv_record != *listHead);
 
188
 
 
189
    return nsnull;
 
190
}
 
191
 
 
192
void
 
193
jsds_InvalidateAllEphemerals (LiveEphemeral **listHead)
 
194
{
 
195
    LiveEphemeral *lv_record = 
 
196
        NS_REINTERPRET_CAST (LiveEphemeral *,
 
197
                             PR_NEXT_LINK(&(*listHead)->links));
 
198
    while (*listHead)
 
199
    {
 
200
        LiveEphemeral *next =
 
201
            NS_REINTERPRET_CAST (LiveEphemeral *,
 
202
                                 PR_NEXT_LINK(&lv_record->links));
 
203
        lv_record->value->Invalidate();
 
204
        lv_record = next;
 
205
    }
 
206
}
 
207
 
 
208
void
 
209
jsds_InsertEphemeral (LiveEphemeral **listHead, LiveEphemeral *item)
 
210
{
 
211
    if (*listHead) {
 
212
        /* if the list exists, add to it */
 
213
        PR_APPEND_LINK(&item->links, &(*listHead)->links);
 
214
    } else {
 
215
        /* otherwise create the list */
 
216
        PR_INIT_CLIST(&item->links);
 
217
        *listHead = item;
 
218
    }
 
219
}
 
220
 
 
221
void
 
222
jsds_RemoveEphemeral (LiveEphemeral **listHead, LiveEphemeral *item)
 
223
{
 
224
    LiveEphemeral *next = NS_REINTERPRET_CAST (LiveEphemeral *,
 
225
                                               PR_NEXT_LINK(&item->links));
 
226
 
 
227
    if (next == item)
 
228
    {
 
229
        /* if the current item is also the next item, we're the only element,
 
230
         * null out the list head */
 
231
        NS_ASSERTION (*listHead == item,
 
232
                      "How could we not be the head of a one item list?");
 
233
        *listHead = nsnull;
 
234
    }
 
235
    else if (item == *listHead)
 
236
    {
 
237
        /* otherwise, if we're currently the list head, change it */
 
238
        *listHead = next;
 
239
    }
 
240
    
 
241
    PR_REMOVE_AND_INIT_LINK(&item->links);
 
242
}
 
243
 
 
244
/*******************************************************************************
 
245
 * utility functions for filters
 
246
 *******************************************************************************/
 
247
void
 
248
jsds_FreeFilter (FilterRecord *filter)
 
249
{
 
250
    NS_IF_RELEASE (filter->filterObject);
 
251
    if (filter->urlPattern)
 
252
        nsMemory::Free(filter->urlPattern);
 
253
    PR_Free (filter);
 
254
}
 
255
 
 
256
/* copies appropriate |filter| attributes into |rec|.
 
257
 * False return indicates failure, the contents of |rec| will not be changed.
 
258
 */
 
259
PRBool
 
260
jsds_SyncFilter (FilterRecord *rec, jsdIFilter *filter)
 
261
{
 
262
    NS_ASSERTION (rec, "jsds_SyncFilter without rec");
 
263
    NS_ASSERTION (filter, "jsds_SyncFilter without filter");
 
264
    
 
265
    JSObject *glob_proper = nsnull;
 
266
    nsCOMPtr<nsISupports> glob;
 
267
    nsresult rv = filter->GetGlobalObject(getter_AddRefs(glob));
 
268
    if (NS_FAILED(rv))
 
269
        return PR_FALSE;
 
270
    if (glob) {
 
271
        nsCOMPtr<nsIScriptGlobalObject> nsiglob = do_QueryInterface(glob);
 
272
        if (nsiglob)
 
273
            glob_proper = nsiglob->GetGlobalJSObject();
 
274
    }
 
275
    
 
276
    PRUint32 startLine;
 
277
    rv = filter->GetStartLine(&startLine);
 
278
    if (NS_FAILED(rv))
 
279
        return PR_FALSE;
 
280
 
 
281
    PRUint32 endLine;
 
282
    rv = filter->GetStartLine(&endLine);
 
283
    if (NS_FAILED(rv))
 
284
        return PR_FALSE;    
 
285
 
 
286
    char *urlPattern;
 
287
    rv = filter->GetUrlPattern (&urlPattern);
 
288
    if (NS_FAILED(rv))
 
289
        return PR_FALSE;
 
290
    
 
291
    if (urlPattern) {
 
292
        PRUint32 len = PL_strlen(urlPattern);
 
293
        if (urlPattern[0] == '*') {
 
294
            /* pattern starts with a *, shift all chars once to the left,
 
295
             * including the trailing null. */
 
296
            memmove (&urlPattern[0], &urlPattern[1], len);
 
297
 
 
298
            if (urlPattern[len - 2] == '*') {
 
299
                /* pattern is in the format "*foo*", overwrite the final * with
 
300
                 * a null. */
 
301
                urlPattern[len - 2] = '\0';
 
302
                rec->patternType = ptContains;
 
303
                rec->patternLength = len - 2;
 
304
            } else {
 
305
                /* pattern is in the format "*foo", just make a note of the
 
306
                 * new length. */
 
307
                rec->patternType = ptEndsWith;
 
308
                rec->patternLength = len - 1;
 
309
            }
 
310
        } else if (urlPattern[len - 1] == '*') {
 
311
            /* pattern is in the format "foo*", overwrite the final * with a 
 
312
             * null. */
 
313
            urlPattern[len - 1] = '\0';
 
314
            rec->patternType = ptStartsWith;
 
315
            rec->patternLength = len - 1;
 
316
        } else {
 
317
            /* pattern is in the format "foo". */
 
318
            rec->patternType = ptEquals;
 
319
            rec->patternLength = len;
 
320
        }
 
321
    } else {
 
322
        rec->patternType = ptIgnore;
 
323
        rec->patternLength = 0;
 
324
    }
 
325
 
 
326
    /* we got everything we need without failing, now copy it into rec. */
 
327
 
 
328
    if (rec->filterObject != filter) {
 
329
        NS_IF_RELEASE(rec->filterObject);
 
330
        NS_ADDREF(filter);
 
331
        rec->filterObject = filter;
 
332
    }
 
333
    
 
334
    rec->glob = glob_proper;
 
335
    
 
336
    rec->startLine     = startLine;
 
337
    rec->endLine       = endLine;
 
338
    
 
339
    if (rec->urlPattern)
 
340
        nsMemory::Free (rec->urlPattern);
 
341
    rec->urlPattern = urlPattern;
 
342
 
 
343
    return PR_TRUE;
 
344
            
 
345
}
 
346
 
 
347
FilterRecord *
 
348
jsds_FindFilter (jsdIFilter *filter)
 
349
{
 
350
    if (!gFilters)
 
351
        return nsnull;
 
352
    
 
353
    FilterRecord *current = gFilters;
 
354
    
 
355
    do {
 
356
        if (current->filterObject == filter)
 
357
            return current;
 
358
        current = NS_REINTERPRET_CAST(FilterRecord *,
 
359
                                      PR_NEXT_LINK(&current->links));
 
360
    } while (current != gFilters);
 
361
    
 
362
    return nsnull;
 
363
}
 
364
 
 
365
/* returns true if the hook should be executed. */
 
366
PRBool
 
367
jsds_FilterHook (JSDContext *jsdc, JSDThreadState *state)
 
368
{
 
369
    JSContext *cx = JSD_GetJSContext (jsdc, state);
 
370
    void *glob = NS_STATIC_CAST(void *, JS_GetGlobalObject (cx));
 
371
 
 
372
    if (!glob) {
 
373
        NS_WARNING("No global in threadstate");
 
374
        return PR_FALSE;
 
375
    }
 
376
    
 
377
    JSDStackFrameInfo *frame = JSD_GetStackFrame (jsdc, state);
 
378
 
 
379
    if (!frame) {
 
380
        NS_WARNING("No frame in threadstate");
 
381
        return PR_FALSE;
 
382
    }
 
383
 
 
384
    JSDScript *script = JSD_GetScriptForStackFrame (jsdc, state, frame);
 
385
    if (!script)
 
386
        return PR_TRUE;
 
387
 
 
388
    jsuint pc = JSD_GetPCForStackFrame (jsdc, state, frame);
 
389
 
 
390
    const char *url = JSD_GetScriptFilename (jsdc, script);
 
391
    if (!url) {
 
392
        NS_WARNING ("Script with no filename");
 
393
        return PR_FALSE;
 
394
    }
 
395
 
 
396
    if (!gFilters)
 
397
        return PR_TRUE;    
 
398
 
 
399
    PRUint32 currentLine = JSD_GetClosestLine (jsdc, script, pc);
 
400
    PRUint32 len = 0;
 
401
    FilterRecord *currentFilter = gFilters;
 
402
    do {
 
403
        PRUint32 flags = 0;
 
404
        nsresult rv = currentFilter->filterObject->GetFlags(&flags);
 
405
        NS_ASSERTION(NS_SUCCEEDED(rv), "Error getting flags for filter");
 
406
        if (flags & jsdIFilter::FLAG_ENABLED) {
 
407
            /* if there is no glob, or the globs match */
 
408
            if ((!currentFilter->glob || currentFilter->glob == glob) &&
 
409
                /* and there is no start line, or the start line is before 
 
410
                 * or equal to the current */
 
411
                (!currentFilter->startLine || 
 
412
                 currentFilter->startLine <= currentLine) &&
 
413
                /* and there is no end line, or the end line is after
 
414
                 * or equal to the current */
 
415
                (!currentFilter->endLine ||
 
416
                 currentFilter->endLine >= currentLine)) {
 
417
                /* then we're going to have to compare the url. */
 
418
                if (currentFilter->patternType == ptIgnore)
 
419
                    return flags & jsdIFilter::FLAG_PASS;
 
420
 
 
421
                if (!len)
 
422
                    len = PL_strlen(url);
 
423
                
 
424
                if (len >= currentFilter->patternLength) {
 
425
                    switch (currentFilter->patternType) {
 
426
                        case ptEquals:
 
427
                            if (!PL_strcmp(currentFilter->urlPattern, url))
 
428
                                return flags & jsdIFilter::FLAG_PASS;
 
429
                            break;
 
430
                        case ptStartsWith:
 
431
                            if (!PL_strncmp(currentFilter->urlPattern, url, 
 
432
                                           currentFilter->patternLength))
 
433
                                return flags & jsdIFilter::FLAG_PASS;
 
434
                            break;
 
435
                        case ptEndsWith:
 
436
                            if (!PL_strcmp(currentFilter->urlPattern,
 
437
                                           &url[len - 
 
438
                                               currentFilter->patternLength]))
 
439
                                return flags & jsdIFilter::FLAG_PASS;
 
440
                            break;
 
441
                        case ptContains:
 
442
                            if (PL_strstr(url, currentFilter->urlPattern))
 
443
                                return flags & jsdIFilter::FLAG_PASS;
 
444
                            break;
 
445
                        default:
 
446
                            NS_ASSERTION(0, "Invalid pattern type");
 
447
                    }
 
448
                }                
 
449
            }
 
450
        }
 
451
        currentFilter = NS_REINTERPRET_CAST(FilterRecord *,
 
452
                                            PR_NEXT_LINK(&currentFilter->links));
 
453
    } while (currentFilter != gFilters);
 
454
 
 
455
    return PR_TRUE;
 
456
    
 
457
}
 
458
 
 
459
/*******************************************************************************
 
460
 * c callbacks
 
461
 *******************************************************************************/
 
462
 
 
463
JS_STATIC_DLL_CALLBACK (void)
 
464
jsds_NotifyPendingDeadScripts (JSContext *cx)
 
465
{
 
466
    nsCOMPtr<jsdIScriptHook> hook = 0;   
 
467
    gJsds->GetScriptHook (getter_AddRefs(hook));
 
468
 
 
469
    DeadScript *ds;
 
470
#ifdef CAUTIOUS_SCRIPTHOOK
 
471
    JSRuntime *rt = JS_GetRuntime(cx);
 
472
#endif
 
473
    gJsds->Pause(nsnull);
 
474
    while (gDeadScripts) {
 
475
        ds = gDeadScripts;
 
476
        
 
477
        if (hook)
 
478
        {
 
479
            /* tell the user this script has been destroyed */
 
480
#ifdef CAUTIOUS_SCRIPTHOOK
 
481
            JS_DISABLE_GC(rt);
 
482
#endif
 
483
            hook->OnScriptDestroyed (ds->script);
 
484
#ifdef CAUTIOUS_SCRIPTHOOK
 
485
            JS_ENABLE_GC(rt);
 
486
#endif
 
487
        }
 
488
        /* get next deleted script */
 
489
        gDeadScripts = NS_REINTERPRET_CAST(DeadScript *,
 
490
                                           PR_NEXT_LINK(&ds->links));
 
491
        if (gDeadScripts == ds) {
 
492
            /* last script in the list */
 
493
            gDeadScripts = nsnull;
 
494
        }
 
495
        
 
496
        /* take ourselves out of the circular list */
 
497
        PR_REMOVE_LINK(&ds->links);
 
498
        /* addref came from the FromPtr call in jsds_ScriptHookProc */
 
499
        NS_RELEASE(ds->script);
 
500
        /* free the struct! */
 
501
        PR_Free(ds);
 
502
    }
 
503
 
 
504
    gJsds->UnPause(nsnull);
 
505
}
 
506
 
 
507
JS_STATIC_DLL_CALLBACK (JSBool)
 
508
jsds_GCCallbackProc (JSContext *cx, JSGCStatus status)
 
509
{
 
510
    gGCStatus = status;
 
511
#ifdef DEBUG_verbose
 
512
    printf ("new gc status is %i\n", status);
 
513
#endif
 
514
    if (status == JSGC_END && gDeadScripts)
 
515
        jsds_NotifyPendingDeadScripts (cx);
 
516
    
 
517
    if (gLastGCProc)
 
518
        return gLastGCProc (cx, status);
 
519
    
 
520
    return JS_TRUE;
 
521
}
 
522
 
 
523
JS_STATIC_DLL_CALLBACK (uintN)
 
524
jsds_ErrorHookProc (JSDContext *jsdc, JSContext *cx, const char *message,
 
525
                    JSErrorReport *report, void *callerdata)
 
526
{
 
527
    static PRBool running = PR_FALSE;
 
528
 
 
529
    nsCOMPtr<jsdIErrorHook> hook;
 
530
    gJsds->GetErrorHook(getter_AddRefs(hook));
 
531
    if (!hook)
 
532
        return JSD_ERROR_REPORTER_PASS_ALONG;
 
533
 
 
534
    if (running)
 
535
        return JSD_ERROR_REPORTER_PASS_ALONG;
 
536
    
 
537
    running = PR_TRUE;
 
538
    
 
539
    nsCOMPtr<jsdIValue> val;
 
540
    if (JS_IsExceptionPending(cx)) {
 
541
        jsval jv;
 
542
        JS_GetPendingException(cx, &jv);
 
543
        JSDValue *jsdv = JSD_NewValue (jsdc, jv);
 
544
        val = getter_AddRefs(jsdValue::FromPtr(jsdc, jsdv));
 
545
    }
 
546
    
 
547
    const char *fileName;
 
548
    PRUint32    line;
 
549
    PRUint32    pos;
 
550
    PRUint32    flags;
 
551
    PRUint32    errnum;
 
552
    PRBool      rval;
 
553
    if (report) {
 
554
        fileName = report->filename;
 
555
        line = report->lineno;
 
556
        pos = report->tokenptr - report->linebuf;
 
557
        flags = report->flags;
 
558
        errnum = report->errorNumber;
 
559
    }
 
560
    else
 
561
    {
 
562
        fileName = 0;
 
563
        line     = 0;
 
564
        pos      = 0;
 
565
        flags    = 0;
 
566
        errnum   = 0;
 
567
    }
 
568
    
 
569
    gJsds->Pause(nsnull);
 
570
    hook->OnError (message, fileName, line, pos, flags, errnum, val, &rval);
 
571
    gJsds->UnPause(nsnull);
 
572
    
 
573
    running = PR_FALSE;
 
574
    if (!rval)
 
575
        return JSD_ERROR_REPORTER_DEBUG;
 
576
    
 
577
    return JSD_ERROR_REPORTER_PASS_ALONG;
 
578
}
 
579
 
 
580
JS_STATIC_DLL_CALLBACK (JSBool)
 
581
jsds_CallHookProc (JSDContext* jsdc, JSDThreadState* jsdthreadstate,
 
582
                   uintN type, void* callerdata)
 
583
{
 
584
    nsCOMPtr<jsdICallHook> hook;
 
585
 
 
586
    switch (type)
 
587
    {
 
588
        case JSD_HOOK_TOPLEVEL_START:
 
589
        case JSD_HOOK_TOPLEVEL_END:
 
590
            gJsds->GetTopLevelHook(getter_AddRefs(hook));
 
591
            break;
 
592
            
 
593
        case JSD_HOOK_FUNCTION_CALL:
 
594
        case JSD_HOOK_FUNCTION_RETURN:
 
595
            gJsds->GetFunctionHook(getter_AddRefs(hook));
 
596
            break;
 
597
 
 
598
        default:
 
599
            NS_ASSERTION (0, "Unknown hook type.");
 
600
    }
 
601
    
 
602
    if (!hook)
 
603
        return JS_TRUE;
 
604
 
 
605
    if (!jsds_FilterHook (jsdc, jsdthreadstate))
 
606
        return JS_FALSE;
 
607
 
 
608
    JSDStackFrameInfo *native_frame = JSD_GetStackFrame (jsdc, jsdthreadstate);
 
609
    nsCOMPtr<jsdIStackFrame> frame =
 
610
        getter_AddRefs(jsdStackFrame::FromPtr(jsdc, jsdthreadstate,
 
611
                                              native_frame));
 
612
    gJsds->Pause(nsnull);
 
613
    hook->OnCall(frame, type);    
 
614
    gJsds->UnPause(nsnull);
 
615
    jsdStackFrame::InvalidateAll();
 
616
 
 
617
    return JS_TRUE;
 
618
}
 
619
 
 
620
JS_STATIC_DLL_CALLBACK (PRUint32)
 
621
jsds_ExecutionHookProc (JSDContext* jsdc, JSDThreadState* jsdthreadstate,
 
622
                        uintN type, void* callerdata, jsval* rval)
 
623
{
 
624
    nsCOMPtr<jsdIExecutionHook> hook(0);
 
625
    PRUint32 hook_rv = JSD_HOOK_RETURN_CONTINUE;
 
626
    nsCOMPtr<jsdIValue> js_rv;
 
627
 
 
628
    switch (type)
 
629
    {
 
630
        case JSD_HOOK_INTERRUPTED:
 
631
            gJsds->GetInterruptHook(getter_AddRefs(hook));
 
632
            break;
 
633
        case JSD_HOOK_DEBUG_REQUESTED:
 
634
            gJsds->GetDebugHook(getter_AddRefs(hook));
 
635
            break;
 
636
        case JSD_HOOK_DEBUGGER_KEYWORD:
 
637
            gJsds->GetDebuggerHook(getter_AddRefs(hook));
 
638
            break;
 
639
        case JSD_HOOK_BREAKPOINT:
 
640
            {
 
641
                /* we can't pause breakpoints the way we pause the other
 
642
                 * execution hooks (at least, not easily.)  Instead we bail
 
643
                 * here if the service is paused. */
 
644
                PRUint32 level;
 
645
                gJsds->GetPauseDepth(&level);
 
646
                if (!level)
 
647
                    gJsds->GetBreakpointHook(getter_AddRefs(hook));
 
648
            }
 
649
            break;
 
650
        case JSD_HOOK_THROW:
 
651
        {
 
652
            hook_rv = JSD_HOOK_RETURN_CONTINUE_THROW;
 
653
            gJsds->GetThrowHook(getter_AddRefs(hook));
 
654
            if (hook) {
 
655
                JSDValue *jsdv = JSD_GetException (jsdc, jsdthreadstate);
 
656
                js_rv = getter_AddRefs(jsdValue::FromPtr (jsdc, jsdv));
 
657
            }
 
658
            break;
 
659
        }
 
660
        default:
 
661
            NS_ASSERTION (0, "Unknown hook type.");
 
662
    }
 
663
 
 
664
    if (!hook)
 
665
        return hook_rv;
 
666
    
 
667
    if (!jsds_FilterHook (jsdc, jsdthreadstate))
 
668
        return JSD_HOOK_RETURN_CONTINUE;
 
669
    
 
670
    JSDStackFrameInfo *native_frame = JSD_GetStackFrame (jsdc, jsdthreadstate);
 
671
    nsCOMPtr<jsdIStackFrame> frame =
 
672
        getter_AddRefs(jsdStackFrame::FromPtr(jsdc, jsdthreadstate,
 
673
                                              native_frame));
 
674
    gJsds->Pause(nsnull);
 
675
    jsdIValue *inout_rv = js_rv;
 
676
    NS_IF_ADDREF(inout_rv);
 
677
    hook->OnExecute (frame, type, &inout_rv, &hook_rv);
 
678
    js_rv = inout_rv;
 
679
    NS_IF_RELEASE(inout_rv);
 
680
    gJsds->UnPause(nsnull);
 
681
    jsdStackFrame::InvalidateAll();
 
682
        
 
683
    if (hook_rv == JSD_HOOK_RETURN_RET_WITH_VAL ||
 
684
        hook_rv == JSD_HOOK_RETURN_THROW_WITH_VAL) {
 
685
        if (js_rv) {
 
686
            JSDValue *jsdv;
 
687
            js_rv->GetJSDValue (&jsdv);
 
688
            *rval = JSD_GetValueWrappedJSVal(jsdc, jsdv);
 
689
        } else {
 
690
            *rval = JSVAL_VOID;
 
691
        }
 
692
    }
 
693
    
 
694
    return hook_rv;
 
695
}
 
696
 
 
697
JS_STATIC_DLL_CALLBACK (void)
 
698
jsds_ScriptHookProc (JSDContext* jsdc, JSDScript* jsdscript, JSBool creating,
 
699
                     void* callerdata)
 
700
{
 
701
#ifdef CAUTIOUS_SCRIPTHOOK
 
702
    JSContext *cx = JSD_GetDefaultJSContext(jsdc);
 
703
    JSRuntime *rt = JS_GetRuntime(cx);
 
704
#endif
 
705
 
 
706
    nsCOMPtr<jsdIScriptHook> hook;
 
707
    gJsds->GetScriptHook (getter_AddRefs(hook));
 
708
    
 
709
    if (creating) {
 
710
        /* a script is being created */
 
711
        if (!hook) {
 
712
            /* nobody cares, just exit */
 
713
            return;
 
714
        }
 
715
            
 
716
        nsCOMPtr<jsdIScript> script = 
 
717
            getter_AddRefs(jsdScript::FromPtr(jsdc, jsdscript));
 
718
#ifdef CAUTIOUS_SCRIPTHOOK
 
719
        JS_DISABLE_GC(rt);
 
720
#endif
 
721
        gJsds->Pause(nsnull);
 
722
        hook->OnScriptCreated (script);
 
723
        gJsds->UnPause(nsnull);
 
724
#ifdef CAUTIOUS_SCRIPTHOOK
 
725
        JS_ENABLE_GC(rt);
 
726
#endif
 
727
    } else {
 
728
        /* a script is being destroyed.  even if there is no registered hook
 
729
         * we'll still need to invalidate the jsdIScript record, in order
 
730
         * to remove the reference held in the JSDScript private data. */
 
731
        nsCOMPtr<jsdIScript> jsdis = 
 
732
            NS_STATIC_CAST(jsdIScript *, JSD_GetScriptPrivate(jsdscript));
 
733
        if (!jsdis)
 
734
            return;
 
735
        
 
736
        jsdis->Invalidate();
 
737
        if (!hook)
 
738
            return;
 
739
        
 
740
        if (gGCStatus == JSGC_END) {
 
741
            /* if GC *isn't* running, we can tell the user about the script
 
742
             * delete now. */
 
743
#ifdef CAUTIOUS_SCRIPTHOOK
 
744
            JS_DISABLE_GC(rt);
 
745
#endif
 
746
                
 
747
            gJsds->Pause(nsnull);
 
748
            hook->OnScriptDestroyed (jsdis);
 
749
            gJsds->UnPause(nsnull);
 
750
#ifdef CAUTIOUS_SCRIPTHOOK
 
751
            JS_ENABLE_GC(rt);
 
752
#endif
 
753
        } else {
 
754
            /* if a GC *is* running, we've got to wait until it's done before
 
755
             * we can execute any JS, so we queue the notification in a PRCList
 
756
             * until GC tells us it's done. See jsds_GCCallbackProc(). */
 
757
            DeadScript *ds = PR_NEW(DeadScript);
 
758
            if (!ds)
 
759
                return; /* NS_ERROR_OUT_OF_MEMORY */
 
760
        
 
761
            ds->jsdc = jsdc;
 
762
            ds->script = jsdis;
 
763
            NS_ADDREF(ds->script);
 
764
            if (gDeadScripts)
 
765
                /* if the queue exists, add to it */
 
766
                PR_APPEND_LINK(&ds->links, &gDeadScripts->links);
 
767
            else {
 
768
                /* otherwise create the queue */
 
769
                PR_INIT_CLIST(&ds->links);
 
770
                gDeadScripts = ds;
 
771
            }
 
772
        }
 
773
    }            
 
774
}
 
775
 
 
776
/*******************************************************************************
 
777
 * reflected jsd data structures
 
778
 *******************************************************************************/
 
779
 
 
780
/* Contexts */
 
781
/*
 
782
NS_IMPL_THREADSAFE_ISUPPORTS1(jsdContext, jsdIContext); 
 
783
 
 
784
NS_IMETHODIMP
 
785
jsdContext::GetJSDContext(JSDContext **_rval)
 
786
{
 
787
    *_rval = mCx;
 
788
    return NS_OK;
 
789
}
 
790
*/
 
791
 
 
792
/* Objects */
 
793
NS_IMPL_THREADSAFE_ISUPPORTS1(jsdObject, jsdIObject)
 
794
 
 
795
NS_IMETHODIMP
 
796
jsdObject::GetJSDContext(JSDContext **_rval)
 
797
{
 
798
    *_rval = mCx;
 
799
    return NS_OK;
 
800
}
 
801
 
 
802
NS_IMETHODIMP
 
803
jsdObject::GetJSDObject(JSDObject **_rval)
 
804
{
 
805
    *_rval = mObject;
 
806
    return NS_OK;
 
807
}
 
808
 
 
809
NS_IMETHODIMP
 
810
jsdObject::GetCreatorURL(char **_rval)
 
811
{
 
812
    const char *url = JSD_GetObjectNewURL(mCx, mObject);
 
813
    if (url) {
 
814
        *_rval = PL_strdup(url);
 
815
        if (!*_rval)
 
816
            return NS_ERROR_OUT_OF_MEMORY;
 
817
    } else {
 
818
        *_rval = nsnull;
 
819
    }
 
820
    return NS_OK;
 
821
}
 
822
 
 
823
NS_IMETHODIMP
 
824
jsdObject::GetCreatorLine(PRUint32 *_rval)
 
825
{
 
826
    *_rval = JSD_GetObjectNewLineNumber(mCx, mObject);
 
827
    return NS_OK;
 
828
}
 
829
 
 
830
NS_IMETHODIMP
 
831
jsdObject::GetConstructorURL(char **_rval)
 
832
{
 
833
    const char *url = JSD_GetObjectConstructorURL(mCx, mObject);
 
834
    if (url) {
 
835
        *_rval = PL_strdup(url);
 
836
        if (!*_rval)
 
837
            return NS_ERROR_OUT_OF_MEMORY;
 
838
    } else {
 
839
        *_rval = nsnull;
 
840
    }
 
841
    return NS_OK;
 
842
}
 
843
 
 
844
NS_IMETHODIMP
 
845
jsdObject::GetConstructorLine(PRUint32 *_rval)
 
846
{
 
847
    *_rval = JSD_GetObjectConstructorLineNumber(mCx, mObject);
 
848
    return NS_OK;
 
849
}
 
850
 
 
851
NS_IMETHODIMP
 
852
jsdObject::GetValue(jsdIValue **_rval)
 
853
{
 
854
    JSDValue *jsdv = JSD_GetValueForObject (mCx, mObject);
 
855
    
 
856
    *_rval = jsdValue::FromPtr (mCx, jsdv);
 
857
    return NS_OK;
 
858
}
 
859
 
 
860
/* Properties */
 
861
NS_IMPL_THREADSAFE_ISUPPORTS2(jsdProperty, jsdIProperty, jsdIEphemeral)
 
862
 
 
863
jsdProperty::jsdProperty (JSDContext *aCx, JSDProperty *aProperty) :
 
864
    mCx(aCx), mProperty(aProperty)
 
865
{
 
866
    DEBUG_CREATE ("jsdProperty", gPropertyCount);
 
867
    mValid = (aCx && aProperty);
 
868
    mLiveListEntry.value = this;
 
869
    jsds_InsertEphemeral (&gLiveProperties, &mLiveListEntry);
 
870
}
 
871
 
 
872
jsdProperty::~jsdProperty () 
 
873
{
 
874
    DEBUG_DESTROY ("jsdProperty", gPropertyCount);
 
875
    if (mValid)
 
876
        Invalidate();
 
877
}
 
878
 
 
879
NS_IMETHODIMP
 
880
jsdProperty::Invalidate()
 
881
{
 
882
    ASSERT_VALID_EPHEMERAL;
 
883
    mValid = PR_FALSE;
 
884
    jsds_RemoveEphemeral (&gLiveProperties, &mLiveListEntry);
 
885
    JSD_DropProperty (mCx, mProperty);
 
886
    return NS_OK;
 
887
}
 
888
 
 
889
void
 
890
jsdProperty::InvalidateAll()
 
891
{
 
892
    if (gLiveProperties)
 
893
        jsds_InvalidateAllEphemerals (&gLiveProperties);
 
894
}
 
895
 
 
896
NS_IMETHODIMP
 
897
jsdProperty::GetJSDContext(JSDContext **_rval)
 
898
{
 
899
    *_rval = mCx;
 
900
    return NS_OK;
 
901
}
 
902
 
 
903
NS_IMETHODIMP
 
904
jsdProperty::GetJSDProperty(JSDProperty **_rval)
 
905
{
 
906
    *_rval = mProperty;
 
907
    return NS_OK;
 
908
}
 
909
 
 
910
NS_IMETHODIMP
 
911
jsdProperty::GetIsValid(PRBool *_rval)
 
912
{
 
913
    *_rval = mValid;
 
914
    return NS_OK;
 
915
}
 
916
 
 
917
NS_IMETHODIMP
 
918
jsdProperty::GetAlias(jsdIValue **_rval)
 
919
{
 
920
    JSDValue *jsdv = JSD_GetPropertyValue (mCx, mProperty);
 
921
    
 
922
    *_rval = jsdValue::FromPtr (mCx, jsdv);
 
923
    return NS_OK;
 
924
}
 
925
 
 
926
NS_IMETHODIMP
 
927
jsdProperty::GetFlags(PRUint32 *_rval)
 
928
{
 
929
    *_rval = JSD_GetPropertyFlags (mCx, mProperty);
 
930
    return NS_OK;
 
931
}
 
932
 
 
933
NS_IMETHODIMP
 
934
jsdProperty::GetName(jsdIValue **_rval)
 
935
{
 
936
    JSDValue *jsdv = JSD_GetPropertyName (mCx, mProperty);
 
937
    
 
938
    *_rval = jsdValue::FromPtr (mCx, jsdv);
 
939
    return NS_OK;
 
940
}
 
941
 
 
942
NS_IMETHODIMP
 
943
jsdProperty::GetValue(jsdIValue **_rval)
 
944
{
 
945
    JSDValue *jsdv = JSD_GetPropertyValue (mCx, mProperty);
 
946
    
 
947
    *_rval = jsdValue::FromPtr (mCx, jsdv);
 
948
    return NS_OK;
 
949
}
 
950
 
 
951
NS_IMETHODIMP
 
952
jsdProperty::GetVarArgSlot(PRUint32 *_rval)
 
953
{
 
954
    *_rval = JSD_GetPropertyVarArgSlot (mCx, mProperty);
 
955
    return NS_OK;
 
956
}
 
957
 
 
958
/* Scripts */
 
959
NS_IMPL_THREADSAFE_ISUPPORTS2(jsdScript, jsdIScript, jsdIEphemeral)
 
960
 
 
961
jsdScript::jsdScript (JSDContext *aCx, JSDScript *aScript) : mValid(PR_FALSE),
 
962
                                                             mTag(0),
 
963
                                                             mCx(aCx),
 
964
                                                             mScript(aScript),
 
965
                                                             mFileName(0), 
 
966
                                                             mFunctionName(0),
 
967
                                                             mBaseLineNumber(0),
 
968
                                                             mLineExtent(0),
 
969
                                                             mPPLineMap(0),
 
970
                                                             mFirstPC(0)
 
971
{
 
972
    DEBUG_CREATE ("jsdScript", gScriptCount);
 
973
 
 
974
    if (mScript) {
 
975
        /* copy the script's information now, so we have it later, when it
 
976
         * gets destroyed. */
 
977
        JSD_LockScriptSubsystem(mCx);
 
978
        mFileName = new nsCString(JSD_GetScriptFilename(mCx, mScript));
 
979
        mFunctionName =
 
980
            new nsCString(JSD_GetScriptFunctionName(mCx, mScript));
 
981
        mBaseLineNumber = JSD_GetScriptBaseLineNumber(mCx, mScript);
 
982
        mLineExtent = JSD_GetScriptLineExtent(mCx, mScript);
 
983
        mFirstPC = JSD_GetClosestPC(mCx, mScript, 0);
 
984
        JSD_UnlockScriptSubsystem(mCx);
 
985
        
 
986
        mValid = PR_TRUE;
 
987
    }
 
988
}
 
989
 
 
990
jsdScript::~jsdScript () 
 
991
{
 
992
    DEBUG_DESTROY ("jsdScript", gScriptCount);
 
993
    if (mFileName)
 
994
        delete mFileName;
 
995
    if (mFunctionName)
 
996
        delete mFunctionName;
 
997
 
 
998
    if (mPPLineMap)
 
999
        PR_Free(mPPLineMap);
 
1000
 
 
1001
    /* Invalidate() needs to be called to release an owning reference to
 
1002
     * ourselves, so if we got here without being invalidated, something
 
1003
     * has gone wrong with our ref count. */
 
1004
    NS_ASSERTION (!mValid, "Script destroyed without being invalidated.");
 
1005
}
 
1006
 
 
1007
/*
 
1008
 * This method populates a line <-> pc map for a pretty printed version of this
 
1009
 * script.  It does this by decompiling, and then recompiling the script.  The
 
1010
 * resulting script is scanned for the line map, and then left as GC fodder.
 
1011
 */
 
1012
PCMapEntry *
 
1013
jsdScript::CreatePPLineMap()
 
1014
{    
 
1015
    JSContext  *cx  = JSD_GetDefaultJSContext (mCx);
 
1016
    JSObject   *obj = JS_NewObject(cx, NULL, NULL, NULL);
 
1017
    JSFunction *fun = JSD_GetJSFunction (mCx, mScript);
 
1018
    JSScript   *script;
 
1019
    PRUint32    baseLine;
 
1020
    PRBool      scriptOwner = PR_FALSE;
 
1021
    
 
1022
    if (fun) {
 
1023
        if (fun->nargs > 12)
 
1024
            return nsnull;
 
1025
        JSString *jsstr = JS_DecompileFunctionBody (cx, fun, 4);
 
1026
        if (!jsstr)
 
1027
            return nsnull;
 
1028
    
 
1029
        const char *argnames[] = {"arg1", "arg2", "arg3", "arg4", 
 
1030
                                  "arg5", "arg6", "arg7", "arg8",
 
1031
                                  "arg9", "arg10", "arg11", "arg12" };
 
1032
        fun = JS_CompileUCFunction (cx, obj, "ppfun", fun->nargs, argnames,
 
1033
                                    JS_GetStringChars(jsstr),
 
1034
                                    JS_GetStringLength(jsstr),
 
1035
                                    "x-jsd:ppbuffer?type=function", 3);
 
1036
        if (!fun || !(script = JS_GetFunctionScript(cx, fun)))
 
1037
            return nsnull;
 
1038
        baseLine = 3;
 
1039
    } else {
 
1040
        JSString *jsstr = JS_DecompileScript (cx, JSD_GetJSScript(mCx, mScript),
 
1041
                                              "ppscript", 4);
 
1042
        if (!jsstr)
 
1043
            return nsnull;
 
1044
 
 
1045
        script = JS_CompileUCScript (cx, obj,
 
1046
                                     JS_GetStringChars(jsstr),
 
1047
                                     JS_GetStringLength(jsstr),
 
1048
                                     "x-jsd:ppbuffer?type=script", 1);
 
1049
        if (!script)
 
1050
            return nsnull;
 
1051
        scriptOwner = PR_TRUE;
 
1052
        baseLine = 1;
 
1053
    }
 
1054
        
 
1055
    PRUint32 scriptExtent = JS_GetScriptLineExtent (cx, script);
 
1056
    jsbytecode* firstPC = JS_LineNumberToPC (cx, script, 0);
 
1057
    /* allocate worst case size of map (number of lines in script + 1
 
1058
     * for our 0 record), we'll shrink it with a realloc later. */
 
1059
    mPPLineMap = 
 
1060
        NS_STATIC_CAST(PCMapEntry *,
 
1061
                       PR_Malloc((scriptExtent + 1) * sizeof (PCMapEntry)));
 
1062
    if (mPPLineMap) {             
 
1063
        mPCMapSize = 0;
 
1064
        for (PRUint32 line = baseLine; line < scriptExtent + baseLine; ++line) {
 
1065
            jsbytecode* pc = JS_LineNumberToPC (cx, script, line);
 
1066
            if (line == JS_PCToLineNumber (cx, script, pc)) {
 
1067
                mPPLineMap[mPCMapSize].line = line;
 
1068
                mPPLineMap[mPCMapSize].pc = pc - firstPC;
 
1069
                ++mPCMapSize;
 
1070
            }
 
1071
        }
 
1072
        if (scriptExtent != mPCMapSize) {
 
1073
            mPPLineMap =
 
1074
                NS_STATIC_CAST(PCMapEntry *,
 
1075
                               PR_Realloc(mPPLineMap,
 
1076
                                          mPCMapSize * sizeof(PCMapEntry)));
 
1077
        }
 
1078
    }
 
1079
 
 
1080
    if (scriptOwner)
 
1081
        JS_DestroyScript (cx, script);
 
1082
 
 
1083
    return mPPLineMap;
 
1084
}
 
1085
 
 
1086
PRUint32
 
1087
jsdScript::PPPcToLine (PRUint32 aPC)
 
1088
{
 
1089
    if (!mPPLineMap && !CreatePPLineMap())
 
1090
        return 0;
 
1091
    PRUint32 i;
 
1092
    for (i = 1; i < mPCMapSize; ++i) {
 
1093
        if (mPPLineMap[i].pc > aPC)
 
1094
            return mPPLineMap[i - 1].line;            
 
1095
    }
 
1096
 
 
1097
    return mPPLineMap[mPCMapSize - 1].line;
 
1098
}
 
1099
 
 
1100
PRUint32
 
1101
jsdScript::PPLineToPc (PRUint32 aLine)
 
1102
{
 
1103
    if (!mPPLineMap && !CreatePPLineMap())
 
1104
        return 0;
 
1105
    PRUint32 i;
 
1106
    for (i = 1; i < mPCMapSize; ++i) {
 
1107
        if (mPPLineMap[i].line > aLine)
 
1108
            return mPPLineMap[i - 1].pc;
 
1109
    }
 
1110
 
 
1111
    return mPPLineMap[mPCMapSize - 1].pc;
 
1112
}
 
1113
 
 
1114
NS_IMETHODIMP
 
1115
jsdScript::GetJSDContext(JSDContext **_rval)
 
1116
{
 
1117
    ASSERT_VALID_EPHEMERAL;
 
1118
    *_rval = mCx;
 
1119
    return NS_OK;
 
1120
}
 
1121
 
 
1122
NS_IMETHODIMP
 
1123
jsdScript::GetJSDScript(JSDScript **_rval)
 
1124
{
 
1125
    ASSERT_VALID_EPHEMERAL;
 
1126
    *_rval = mScript;
 
1127
    return NS_OK;
 
1128
}
 
1129
 
 
1130
NS_IMETHODIMP
 
1131
jsdScript::GetVersion (PRInt32 *_rval)
 
1132
{
 
1133
    ASSERT_VALID_EPHEMERAL;
 
1134
    JSContext *cx = JSD_GetDefaultJSContext (mCx);
 
1135
    JSScript *script = JSD_GetJSScript(mCx, mScript);
 
1136
    *_rval = NS_STATIC_CAST (PRInt32, JS_GetScriptVersion(cx, script));
 
1137
    return NS_OK;
 
1138
}
 
1139
 
 
1140
NS_IMETHODIMP
 
1141
jsdScript::GetTag(PRUint32 *_rval)
 
1142
{
 
1143
    if (!mTag)
 
1144
        mTag = ++jsdScript::LastTag;
 
1145
    
 
1146
    *_rval = mTag;
 
1147
    return NS_OK;
 
1148
}
 
1149
 
 
1150
NS_IMETHODIMP
 
1151
jsdScript::Invalidate()
 
1152
{
 
1153
    ASSERT_VALID_EPHEMERAL;
 
1154
    mValid = PR_FALSE;
 
1155
    
 
1156
    /* release the addref we do in FromPtr */
 
1157
    jsdIScript *script = NS_STATIC_CAST(jsdIScript *,
 
1158
                                        JSD_GetScriptPrivate(mScript));
 
1159
    NS_ASSERTION (script == this, "That's not my script!");
 
1160
    NS_RELEASE(script);
 
1161
    JSD_SetScriptPrivate(mScript, NULL);
 
1162
    return NS_OK;
 
1163
}
 
1164
 
 
1165
void
 
1166
jsdScript::InvalidateAll ()
 
1167
{
 
1168
    JSDContext *cx;
 
1169
    gJsds->GetJSDContext (&cx);
 
1170
    JSDScript *script;
 
1171
    JSDScript *iter = NULL;
 
1172
    
 
1173
    JSD_LockScriptSubsystem(cx);
 
1174
    while((script = JSD_IterateScripts(cx, &iter)) != NULL) {
 
1175
        nsCOMPtr<jsdIScript> jsdis = 
 
1176
            NS_STATIC_CAST(jsdIScript *, JSD_GetScriptPrivate(script));
 
1177
        if (jsdis)
 
1178
            jsdis->Invalidate();
 
1179
    }
 
1180
    JSD_UnlockScriptSubsystem(cx);
 
1181
}
 
1182
 
 
1183
NS_IMETHODIMP
 
1184
jsdScript::GetIsValid(PRBool *_rval)
 
1185
{
 
1186
    *_rval = mValid;
 
1187
    return NS_OK;
 
1188
}
 
1189
 
 
1190
NS_IMETHODIMP
 
1191
jsdScript::SetFlags(PRUint32 flags)
 
1192
{
 
1193
    ASSERT_VALID_EPHEMERAL;
 
1194
    JSD_SetScriptFlags(mCx, mScript, flags);
 
1195
    return NS_OK;
 
1196
}
 
1197
 
 
1198
NS_IMETHODIMP
 
1199
jsdScript::GetFlags(PRUint32 *_rval)
 
1200
{
 
1201
    ASSERT_VALID_EPHEMERAL;
 
1202
    *_rval = JSD_GetScriptFlags(mCx, mScript);
 
1203
    return NS_OK;
 
1204
}
 
1205
 
 
1206
NS_IMETHODIMP
 
1207
jsdScript::GetFileName(char **_rval)
 
1208
{
 
1209
    *_rval = ToNewCString(*mFileName);
 
1210
    if (!*_rval)
 
1211
        return NS_ERROR_OUT_OF_MEMORY;
 
1212
    return NS_OK;
 
1213
}
 
1214
 
 
1215
NS_IMETHODIMP
 
1216
jsdScript::GetFunctionName(char **_rval)
 
1217
{
 
1218
    *_rval = ToNewCString(*mFunctionName);
 
1219
    if (!*_rval)
 
1220
        return NS_ERROR_OUT_OF_MEMORY;
 
1221
    return NS_OK;
 
1222
}
 
1223
 
 
1224
NS_IMETHODIMP
 
1225
jsdScript::GetFunctionObject(jsdIValue **_rval)
 
1226
{
 
1227
    JSFunction *fun = JSD_GetJSFunction(mCx, mScript);
 
1228
    if (!fun)
 
1229
        return NS_ERROR_NOT_AVAILABLE;
 
1230
    
 
1231
    JSObject *obj = JS_GetFunctionObject(fun);
 
1232
    if (!obj)
 
1233
        return NS_ERROR_FAILURE;
 
1234
 
 
1235
    JSDContext *cx;
 
1236
    gJsds->GetJSDContext (&cx);
 
1237
 
 
1238
    JSDValue *jsdv = JSD_NewValue(cx, OBJECT_TO_JSVAL(obj));
 
1239
    if (!jsdv)
 
1240
        return NS_ERROR_FAILURE;
 
1241
 
 
1242
    *_rval = jsdValue::FromPtr(cx, jsdv);
 
1243
    if (!*_rval) {
 
1244
        JSD_DropValue(cx, jsdv);
 
1245
        return NS_ERROR_FAILURE;
 
1246
    }
 
1247
 
 
1248
    return NS_OK;
 
1249
}
 
1250
 
 
1251
NS_IMETHODIMP
 
1252
jsdScript::GetFunctionSource(nsAString & aFunctionSource)
 
1253
{
 
1254
    ASSERT_VALID_EPHEMERAL;
 
1255
    JSContext *cx = JSD_GetDefaultJSContext (mCx);
 
1256
    if (!cx) {
 
1257
        NS_WARNING("No default context !?");
 
1258
        return NS_ERROR_FAILURE;
 
1259
    }
 
1260
    JSFunction *fun = JSD_GetJSFunction (mCx, mScript);
 
1261
    JSString *jsstr;
 
1262
    if (fun)
 
1263
    {
 
1264
        jsstr = JS_DecompileFunction (cx, fun, 4);
 
1265
    }
 
1266
    else
 
1267
    {
 
1268
        JSScript *script = JSD_GetJSScript (mCx, mScript);
 
1269
        jsstr = JS_DecompileScript (cx, script, "ppscript", 4);
 
1270
    }
 
1271
    if (!jsstr)
 
1272
        return NS_ERROR_FAILURE;
 
1273
    aFunctionSource = NS_REINTERPRET_CAST(PRUnichar*, JS_GetStringChars(jsstr));
 
1274
    return NS_OK;
 
1275
}
 
1276
 
 
1277
NS_IMETHODIMP
 
1278
jsdScript::GetBaseLineNumber(PRUint32 *_rval)
 
1279
{
 
1280
    *_rval = mBaseLineNumber;
 
1281
    return NS_OK;
 
1282
}
 
1283
 
 
1284
NS_IMETHODIMP
 
1285
jsdScript::GetLineExtent(PRUint32 *_rval)
 
1286
{
 
1287
    *_rval = mLineExtent;
 
1288
    return NS_OK;
 
1289
}
 
1290
 
 
1291
NS_IMETHODIMP
 
1292
jsdScript::GetCallCount(PRUint32 *_rval)
 
1293
{
 
1294
    ASSERT_VALID_EPHEMERAL;
 
1295
    *_rval = JSD_GetScriptCallCount (mCx, mScript);
 
1296
    return NS_OK;
 
1297
}
 
1298
 
 
1299
NS_IMETHODIMP
 
1300
jsdScript::GetMaxRecurseDepth(PRUint32 *_rval)
 
1301
{
 
1302
    ASSERT_VALID_EPHEMERAL;
 
1303
    *_rval = JSD_GetScriptMaxRecurseDepth (mCx, mScript);
 
1304
    return NS_OK;
 
1305
}
 
1306
 
 
1307
NS_IMETHODIMP
 
1308
jsdScript::GetMinExecutionTime(double *_rval)
 
1309
{
 
1310
    ASSERT_VALID_EPHEMERAL;
 
1311
    *_rval = JSD_GetScriptMinExecutionTime (mCx, mScript);
 
1312
    return NS_OK;
 
1313
}
 
1314
 
 
1315
NS_IMETHODIMP
 
1316
jsdScript::GetMaxExecutionTime(double *_rval)
 
1317
{
 
1318
    ASSERT_VALID_EPHEMERAL;
 
1319
    *_rval = JSD_GetScriptMaxExecutionTime (mCx, mScript);
 
1320
    return NS_OK;
 
1321
}
 
1322
 
 
1323
NS_IMETHODIMP
 
1324
jsdScript::GetTotalExecutionTime(double *_rval)
 
1325
{
 
1326
    ASSERT_VALID_EPHEMERAL;
 
1327
    *_rval = JSD_GetScriptTotalExecutionTime (mCx, mScript);
 
1328
    return NS_OK;
 
1329
}
 
1330
 
 
1331
NS_IMETHODIMP
 
1332
jsdScript::ClearProfileData()
 
1333
{
 
1334
    ASSERT_VALID_EPHEMERAL;
 
1335
    JSD_ClearScriptProfileData(mCx, mScript);
 
1336
    return NS_OK;
 
1337
}
 
1338
 
 
1339
NS_IMETHODIMP
 
1340
jsdScript::PcToLine(PRUint32 aPC, PRUint32 aPcmap, PRUint32 *_rval)
 
1341
{
 
1342
    ASSERT_VALID_EPHEMERAL;
 
1343
    if (aPcmap == PCMAP_SOURCETEXT) {
 
1344
        *_rval = JSD_GetClosestLine (mCx, mScript, mFirstPC + aPC);
 
1345
    } else if (aPcmap == PCMAP_PRETTYPRINT) {
 
1346
        *_rval = PPPcToLine(aPC);
 
1347
    } else {
 
1348
        return NS_ERROR_INVALID_ARG;
 
1349
    }
 
1350
    
 
1351
    return NS_OK;
 
1352
}
 
1353
 
 
1354
NS_IMETHODIMP
 
1355
jsdScript::LineToPc(PRUint32 aLine, PRUint32 aPcmap, PRUint32 *_rval)
 
1356
{
 
1357
    ASSERT_VALID_EPHEMERAL;
 
1358
    if (aPcmap == PCMAP_SOURCETEXT) {
 
1359
        jsuword pc = JSD_GetClosestPC (mCx, mScript, aLine);
 
1360
        *_rval = pc - mFirstPC;
 
1361
    } else if (aPcmap == PCMAP_PRETTYPRINT) {
 
1362
        *_rval = PPLineToPc(aLine);
 
1363
    } else {
 
1364
        return NS_ERROR_INVALID_ARG;
 
1365
    }
 
1366
 
 
1367
    return NS_OK;
 
1368
}
 
1369
 
 
1370
NS_IMETHODIMP
 
1371
jsdScript::IsLineExecutable(PRUint32 aLine, PRUint32 aPcmap, PRBool *_rval)
 
1372
{
 
1373
    ASSERT_VALID_EPHEMERAL;
 
1374
    if (aPcmap == PCMAP_SOURCETEXT) {    
 
1375
        jsuword pc = JSD_GetClosestPC (mCx, mScript, aLine);
 
1376
        *_rval = (aLine == JSD_GetClosestLine (mCx, mScript, pc));
 
1377
    } else if (aPcmap == PCMAP_PRETTYPRINT) {
 
1378
        if (!mPPLineMap && !CreatePPLineMap())
 
1379
            return NS_ERROR_FAILURE;
 
1380
        *_rval = PR_FALSE;
 
1381
        for (PRUint32 i = 0; i < mPCMapSize; ++i) {
 
1382
            if (mPPLineMap[i].line >= aLine) {
 
1383
                *_rval = (mPPLineMap[i].line == aLine);
 
1384
                break;
 
1385
            }
 
1386
        }
 
1387
    } else {
 
1388
        return NS_ERROR_INVALID_ARG;
 
1389
    }
 
1390
    
 
1391
    return NS_OK;
 
1392
}
 
1393
 
 
1394
NS_IMETHODIMP
 
1395
jsdScript::SetBreakpoint(PRUint32 aPC)
 
1396
{
 
1397
    ASSERT_VALID_EPHEMERAL;
 
1398
    jsuword pc = mFirstPC + aPC;
 
1399
    JSD_SetExecutionHook (mCx, mScript, pc, jsds_ExecutionHookProc,
 
1400
                          NS_REINTERPRET_CAST(void *, PRIVATE_TO_JSVAL(NULL)));
 
1401
    return NS_OK;
 
1402
}
 
1403
 
 
1404
NS_IMETHODIMP
 
1405
jsdScript::ClearBreakpoint(PRUint32 aPC)
 
1406
{
 
1407
    ASSERT_VALID_EPHEMERAL;    
 
1408
    jsuword pc = mFirstPC + aPC;
 
1409
    JSD_ClearExecutionHook (mCx, mScript, pc);
 
1410
    return NS_OK;
 
1411
}
 
1412
 
 
1413
NS_IMETHODIMP
 
1414
jsdScript::ClearAllBreakpoints()
 
1415
{
 
1416
    ASSERT_VALID_EPHEMERAL;
 
1417
    JSD_LockScriptSubsystem(mCx);
 
1418
    JSD_ClearAllExecutionHooksForScript (mCx, mScript);
 
1419
    JSD_UnlockScriptSubsystem(mCx);
 
1420
    return NS_OK;
 
1421
}
 
1422
 
 
1423
/* Contexts */
 
1424
NS_IMPL_THREADSAFE_ISUPPORTS2(jsdContext, jsdIContext, jsdIEphemeral)
 
1425
 
 
1426
jsdIContext *
 
1427
jsdContext::FromPtr (JSDContext *aJSDCx, JSContext *aJSCx)
 
1428
{
 
1429
    if (!aJSDCx || !aJSCx ||
 
1430
        !(JS_GetOptions(aJSCx) & JSOPTION_PRIVATE_IS_NSISUPPORTS))
 
1431
    {
 
1432
        return nsnull;
 
1433
    }
 
1434
    
 
1435
    nsCOMPtr<jsdIContext> jsdicx;
 
1436
    nsCOMPtr<jsdIEphemeral> eph = 
 
1437
        jsds_FindEphemeral (&gLiveContexts, NS_STATIC_CAST(void *, aJSCx));
 
1438
    if (eph)
 
1439
    {
 
1440
        jsdicx = do_QueryInterface(eph);
 
1441
    }
 
1442
    else
 
1443
    {
 
1444
        nsCOMPtr<nsISupports> iscx = 
 
1445
            NS_STATIC_CAST(nsISupports *, JS_GetContextPrivate(aJSCx));
 
1446
        if (!iscx)
 
1447
            return nsnull;
 
1448
        
 
1449
        jsdicx = new jsdContext (aJSDCx, aJSCx, iscx);
 
1450
    }
 
1451
 
 
1452
    jsdIContext *rv = jsdicx;
 
1453
    NS_IF_ADDREF(rv);
 
1454
    return rv;
 
1455
}
 
1456
 
 
1457
jsdContext::jsdContext (JSDContext *aJSDCx, JSContext *aJSCx,
 
1458
                        nsISupports *aISCx) : mValid(PR_TRUE), mTag(0),
 
1459
                                              mJSDCx(aJSDCx),
 
1460
                                              mJSCx(aJSCx), mISCx(aISCx)
 
1461
{
 
1462
    DEBUG_CREATE ("jsdContext", gContextCount);
 
1463
    mLiveListEntry.value = this;
 
1464
    mLiveListEntry.key   = NS_STATIC_CAST (void *, aJSCx);
 
1465
    jsds_InsertEphemeral (&gLiveContexts, &mLiveListEntry);
 
1466
}
 
1467
 
 
1468
jsdContext::~jsdContext() 
 
1469
{
 
1470
    DEBUG_DESTROY ("jsdContext", gContextCount);
 
1471
    if (mValid)
 
1472
    {
 
1473
        /* call Invalidate() to take ourselves out of the live list */
 
1474
        Invalidate();
 
1475
    }
 
1476
}
 
1477
 
 
1478
NS_IMETHODIMP
 
1479
jsdContext::GetIsValid(PRBool *_rval)
 
1480
{
 
1481
    *_rval = mValid;
 
1482
    return NS_OK;
 
1483
}
 
1484
 
 
1485
NS_IMETHODIMP
 
1486
jsdContext::Invalidate()
 
1487
{
 
1488
    ASSERT_VALID_EPHEMERAL;
 
1489
    mValid = PR_FALSE;
 
1490
    jsds_RemoveEphemeral (&gLiveContexts, &mLiveListEntry);
 
1491
    return NS_OK;
 
1492
}
 
1493
 
 
1494
void
 
1495
jsdContext::InvalidateAll()
 
1496
{
 
1497
    if (gLiveContexts)
 
1498
        jsds_InvalidateAllEphemerals (&gLiveContexts);
 
1499
}
 
1500
 
 
1501
NS_IMETHODIMP
 
1502
jsdContext::GetJSContext(JSContext **_rval)
 
1503
{
 
1504
    ASSERT_VALID_EPHEMERAL;
 
1505
    *_rval = mJSCx;
 
1506
    return NS_OK;
 
1507
}
 
1508
 
 
1509
NS_IMETHODIMP
 
1510
jsdContext::GetOptions(PRUint32 *_rval)
 
1511
{
 
1512
    ASSERT_VALID_EPHEMERAL;
 
1513
    *_rval = JS_GetOptions(mJSCx);
 
1514
    return NS_OK;
 
1515
}
 
1516
 
 
1517
NS_IMETHODIMP
 
1518
jsdContext::SetOptions(PRUint32 options)
 
1519
{
 
1520
    ASSERT_VALID_EPHEMERAL;
 
1521
    PRUint32 lastOptions = JS_GetOptions(mJSCx);
 
1522
 
 
1523
    /* don't let users change this option, they'd just be shooting themselves
 
1524
     * in the foot. */
 
1525
    if ((options ^ lastOptions) & JSOPTION_PRIVATE_IS_NSISUPPORTS)
 
1526
        return NS_ERROR_ILLEGAL_VALUE;
 
1527
 
 
1528
    JS_SetOptions(mJSCx, options);
 
1529
    return NS_OK;
 
1530
}
 
1531
 
 
1532
NS_IMETHODIMP
 
1533
jsdContext::GetPrivateData(nsISupports **_rval)
 
1534
{
 
1535
    ASSERT_VALID_EPHEMERAL;
 
1536
    PRUint32 options = JS_GetOptions(mJSCx);
 
1537
    if (options & JSOPTION_PRIVATE_IS_NSISUPPORTS)
 
1538
    {
 
1539
        *_rval = NS_STATIC_CAST(nsISupports*, JS_GetContextPrivate(mJSCx));
 
1540
        NS_IF_ADDREF(*_rval);
 
1541
    }
 
1542
    else
 
1543
    {
 
1544
        *_rval = nsnull;
 
1545
    }
 
1546
    
 
1547
    return NS_OK;
 
1548
}
 
1549
        
 
1550
NS_IMETHODIMP
 
1551
jsdContext::GetWrappedContext(nsISupports **_rval)
 
1552
{
 
1553
    ASSERT_VALID_EPHEMERAL;
 
1554
    *_rval = mISCx;
 
1555
    NS_IF_ADDREF(*_rval);
 
1556
    return NS_OK;
 
1557
}
 
1558
 
 
1559
NS_IMETHODIMP
 
1560
jsdContext::GetTag(PRUint32 *_rval)
 
1561
{
 
1562
    ASSERT_VALID_EPHEMERAL;
 
1563
    if (!mTag)
 
1564
        mTag = ++jsdContext::LastTag;
 
1565
    
 
1566
    *_rval = mTag;
 
1567
    return NS_OK;
 
1568
}
 
1569
 
 
1570
NS_IMETHODIMP
 
1571
jsdContext::GetVersion (PRInt32 *_rval)
 
1572
{
 
1573
    ASSERT_VALID_EPHEMERAL;
 
1574
    *_rval = NS_STATIC_CAST (PRInt32, JS_GetVersion(mJSCx));
 
1575
    return NS_OK;
 
1576
}
 
1577
 
 
1578
NS_IMETHODIMP
 
1579
jsdContext::SetVersion (PRInt32 id)
 
1580
{
 
1581
    ASSERT_VALID_EPHEMERAL;
 
1582
    JSVersion ver = NS_STATIC_CAST (JSVersion, id);
 
1583
    JS_SetVersion(mJSCx, ver);
 
1584
    return NS_OK;
 
1585
}
 
1586
 
 
1587
NS_IMETHODIMP
 
1588
jsdContext::GetGlobalObject (jsdIValue **_rval)
 
1589
{
 
1590
    ASSERT_VALID_EPHEMERAL;
 
1591
    JSObject *glob = JS_GetGlobalObject(mJSCx);
 
1592
    JSDValue *jsdv = JSD_NewValue (mJSDCx, OBJECT_TO_JSVAL(glob));
 
1593
    if (!jsdv)
 
1594
        return NS_ERROR_FAILURE;
 
1595
    *_rval = jsdValue::FromPtr (mJSDCx, jsdv);
 
1596
    if (!*_rval)
 
1597
        return NS_ERROR_FAILURE;
 
1598
    return NS_OK;
 
1599
}
 
1600
 
 
1601
NS_IMETHODIMP
 
1602
jsdContext::GetScriptsEnabled (PRBool *_rval)
 
1603
{
 
1604
    ASSERT_VALID_EPHEMERAL;
 
1605
    nsCOMPtr<nsIScriptContext> context = do_QueryInterface(mISCx);
 
1606
    if (!context)
 
1607
        return NS_ERROR_NO_INTERFACE;
 
1608
 
 
1609
    *_rval = context->GetScriptsEnabled();
 
1610
 
 
1611
    return NS_OK;
 
1612
}
 
1613
 
 
1614
NS_IMETHODIMP
 
1615
jsdContext::SetScriptsEnabled (PRBool _rval)
 
1616
{
 
1617
    ASSERT_VALID_EPHEMERAL;
 
1618
    nsCOMPtr<nsIScriptContext> context = do_QueryInterface(mISCx);
 
1619
    if (!context)
 
1620
        return NS_ERROR_NO_INTERFACE;
 
1621
 
 
1622
    context->SetScriptsEnabled(_rval, PR_TRUE);
 
1623
 
 
1624
    return NS_OK;
 
1625
}
 
1626
 
 
1627
/* Stack Frames */
 
1628
NS_IMPL_THREADSAFE_ISUPPORTS2(jsdStackFrame, jsdIStackFrame, jsdIEphemeral)
 
1629
 
 
1630
jsdStackFrame::jsdStackFrame (JSDContext *aCx, JSDThreadState *aThreadState,
 
1631
                              JSDStackFrameInfo *aStackFrameInfo) :
 
1632
    mCx(aCx), mThreadState(aThreadState), mStackFrameInfo(aStackFrameInfo)
 
1633
{
 
1634
    DEBUG_CREATE ("jsdStackFrame", gFrameCount);
 
1635
    mValid = (aCx && aThreadState && aStackFrameInfo);
 
1636
    if (mValid) {
 
1637
        mLiveListEntry.key = aStackFrameInfo;
 
1638
        mLiveListEntry.value = this;
 
1639
        jsds_InsertEphemeral (&gLiveStackFrames, &mLiveListEntry);
 
1640
    }
 
1641
}
 
1642
 
 
1643
jsdStackFrame::~jsdStackFrame() 
 
1644
{
 
1645
    DEBUG_DESTROY ("jsdStackFrame", gFrameCount);
 
1646
    if (mValid)
 
1647
    {
 
1648
        /* call Invalidate() to take ourselves out of the live list */
 
1649
        Invalidate();
 
1650
    }
 
1651
}
 
1652
 
 
1653
jsdIStackFrame *
 
1654
jsdStackFrame::FromPtr (JSDContext *aCx, JSDThreadState *aThreadState,
 
1655
                        JSDStackFrameInfo *aStackFrameInfo)
 
1656
{
 
1657
    if (!aStackFrameInfo)
 
1658
        return nsnull;
 
1659
 
 
1660
    jsdIStackFrame *rv;
 
1661
    nsCOMPtr<jsdIStackFrame> frame;
 
1662
 
 
1663
    nsCOMPtr<jsdIEphemeral> eph =
 
1664
        jsds_FindEphemeral (&gLiveStackFrames,
 
1665
                            NS_REINTERPRET_CAST(void *, aStackFrameInfo));
 
1666
 
 
1667
    if (eph)
 
1668
    {
 
1669
        frame = do_QueryInterface(eph);
 
1670
        rv = frame;
 
1671
    }
 
1672
    else
 
1673
    {
 
1674
        rv = new jsdStackFrame (aCx, aThreadState, aStackFrameInfo);
 
1675
    }
 
1676
 
 
1677
    NS_IF_ADDREF(rv);
 
1678
    return rv;
 
1679
}
 
1680
 
 
1681
NS_IMETHODIMP
 
1682
jsdStackFrame::Invalidate()
 
1683
{
 
1684
    ASSERT_VALID_EPHEMERAL;
 
1685
    mValid = PR_FALSE;
 
1686
    jsds_RemoveEphemeral (&gLiveStackFrames, &mLiveListEntry);
 
1687
    return NS_OK;
 
1688
}
 
1689
 
 
1690
void
 
1691
jsdStackFrame::InvalidateAll()
 
1692
{
 
1693
    if (gLiveStackFrames)
 
1694
        jsds_InvalidateAllEphemerals (&gLiveStackFrames);
 
1695
}
 
1696
 
 
1697
NS_IMETHODIMP
 
1698
jsdStackFrame::GetJSDContext(JSDContext **_rval)
 
1699
{
 
1700
    ASSERT_VALID_EPHEMERAL;
 
1701
    *_rval = mCx;
 
1702
    return NS_OK;
 
1703
}
 
1704
 
 
1705
NS_IMETHODIMP
 
1706
jsdStackFrame::GetJSDThreadState(JSDThreadState **_rval)
 
1707
{
 
1708
    ASSERT_VALID_EPHEMERAL;
 
1709
    *_rval = mThreadState;
 
1710
    return NS_OK;
 
1711
}
 
1712
 
 
1713
NS_IMETHODIMP
 
1714
jsdStackFrame::GetJSDStackFrameInfo(JSDStackFrameInfo **_rval)
 
1715
{
 
1716
    ASSERT_VALID_EPHEMERAL;
 
1717
    *_rval = mStackFrameInfo;
 
1718
    return NS_OK;
 
1719
}
 
1720
 
 
1721
NS_IMETHODIMP
 
1722
jsdStackFrame::GetIsValid(PRBool *_rval)
 
1723
{
 
1724
    *_rval = mValid;
 
1725
    return NS_OK;
 
1726
}
 
1727
 
 
1728
NS_IMETHODIMP
 
1729
jsdStackFrame::GetCallingFrame(jsdIStackFrame **_rval)
 
1730
{
 
1731
    ASSERT_VALID_EPHEMERAL;
 
1732
    JSDStackFrameInfo *sfi = JSD_GetCallingStackFrame (mCx, mThreadState,
 
1733
                                                       mStackFrameInfo);
 
1734
    *_rval = jsdStackFrame::FromPtr (mCx, mThreadState, sfi);
 
1735
    return NS_OK;
 
1736
}
 
1737
 
 
1738
NS_IMETHODIMP
 
1739
jsdStackFrame::GetExecutionContext(jsdIContext **_rval)
 
1740
{
 
1741
    ASSERT_VALID_EPHEMERAL;
 
1742
    JSContext *cx = JSD_GetJSContext (mCx, mThreadState);
 
1743
    *_rval = jsdContext::FromPtr (mCx, cx);
 
1744
    return NS_OK;
 
1745
}
 
1746
 
 
1747
NS_IMETHODIMP
 
1748
jsdStackFrame::GetFunctionName(char **_rval)
 
1749
{
 
1750
    ASSERT_VALID_EPHEMERAL;
 
1751
    const char *name = JSD_GetNameForStackFrame(mCx, mThreadState,
 
1752
                                                mStackFrameInfo);
 
1753
    if (name) {
 
1754
        *_rval = PL_strdup(name);
 
1755
        if (!*_rval)
 
1756
            return NS_ERROR_OUT_OF_MEMORY;
 
1757
    } else {
 
1758
        /* top level scripts have no function name */
 
1759
        *_rval = nsnull;
 
1760
        return NS_OK;
 
1761
    }
 
1762
    return NS_OK;
 
1763
}
 
1764
 
 
1765
NS_IMETHODIMP
 
1766
jsdStackFrame::GetIsNative(PRBool *_rval)
 
1767
{
 
1768
    ASSERT_VALID_EPHEMERAL;
 
1769
    *_rval = JSD_IsStackFrameNative (mCx, mThreadState, mStackFrameInfo);
 
1770
    return NS_OK;
 
1771
}
 
1772
 
 
1773
NS_IMETHODIMP
 
1774
jsdStackFrame::GetIsDebugger(PRBool *_rval)
 
1775
{
 
1776
    ASSERT_VALID_EPHEMERAL;
 
1777
    *_rval = JSD_IsStackFrameDebugger (mCx, mThreadState, mStackFrameInfo);
 
1778
    return NS_OK;
 
1779
}
 
1780
 
 
1781
NS_IMETHODIMP
 
1782
jsdStackFrame::GetIsConstructing(PRBool *_rval)
 
1783
{
 
1784
    ASSERT_VALID_EPHEMERAL;
 
1785
    *_rval = JSD_IsStackFrameConstructing (mCx, mThreadState, mStackFrameInfo);
 
1786
    return NS_OK;
 
1787
}
 
1788
 
 
1789
NS_IMETHODIMP
 
1790
jsdStackFrame::GetScript(jsdIScript **_rval)
 
1791
{
 
1792
    ASSERT_VALID_EPHEMERAL;
 
1793
    JSDScript *script = JSD_GetScriptForStackFrame (mCx, mThreadState,
 
1794
                                                    mStackFrameInfo);
 
1795
    *_rval = jsdScript::FromPtr (mCx, script);
 
1796
    return NS_OK;
 
1797
}
 
1798
 
 
1799
NS_IMETHODIMP
 
1800
jsdStackFrame::GetPc(PRUint32 *_rval)
 
1801
{
 
1802
    ASSERT_VALID_EPHEMERAL;
 
1803
    JSDScript *script = JSD_GetScriptForStackFrame (mCx, mThreadState,
 
1804
                                                    mStackFrameInfo);
 
1805
    if (!script)
 
1806
        return NS_ERROR_FAILURE;
 
1807
    jsuword pcbase = JSD_GetClosestPC(mCx, script, 0);
 
1808
    
 
1809
    jsuword pc = JSD_GetPCForStackFrame (mCx, mThreadState, mStackFrameInfo);
 
1810
    if (pc)
 
1811
        *_rval = pc - pcbase;
 
1812
    else
 
1813
        *_rval = pcbase;
 
1814
    return NS_OK;
 
1815
}
 
1816
 
 
1817
NS_IMETHODIMP
 
1818
jsdStackFrame::GetLine(PRUint32 *_rval)
 
1819
{
 
1820
    ASSERT_VALID_EPHEMERAL;
 
1821
    JSDScript *script = JSD_GetScriptForStackFrame (mCx, mThreadState,
 
1822
                                                    mStackFrameInfo);
 
1823
    if (script) {
 
1824
        jsuword pc = JSD_GetPCForStackFrame (mCx, mThreadState, mStackFrameInfo);
 
1825
        *_rval = JSD_GetClosestLine (mCx, script, pc);
 
1826
    } else {
 
1827
        if (!JSD_IsStackFrameNative(mCx, mThreadState, mStackFrameInfo))
 
1828
            return NS_ERROR_FAILURE;
 
1829
        *_rval = 1;
 
1830
    }
 
1831
    return NS_OK;
 
1832
}
 
1833
 
 
1834
NS_IMETHODIMP
 
1835
jsdStackFrame::GetCallee(jsdIValue **_rval)
 
1836
{
 
1837
    ASSERT_VALID_EPHEMERAL;
 
1838
    JSDValue *jsdv = JSD_GetCallObjectForStackFrame (mCx, mThreadState,
 
1839
                                                     mStackFrameInfo);
 
1840
    
 
1841
    *_rval = jsdValue::FromPtr (mCx, jsdv);
 
1842
    return NS_OK;
 
1843
}
 
1844
 
 
1845
NS_IMETHODIMP
 
1846
jsdStackFrame::GetScope(jsdIValue **_rval)
 
1847
{
 
1848
    ASSERT_VALID_EPHEMERAL;
 
1849
    JSDValue *jsdv = JSD_GetScopeChainForStackFrame (mCx, mThreadState,
 
1850
                                                     mStackFrameInfo);
 
1851
    
 
1852
    *_rval = jsdValue::FromPtr (mCx, jsdv);
 
1853
    return NS_OK;
 
1854
}
 
1855
 
 
1856
NS_IMETHODIMP
 
1857
jsdStackFrame::GetThisValue(jsdIValue **_rval)
 
1858
{
 
1859
    ASSERT_VALID_EPHEMERAL;
 
1860
    JSDValue *jsdv = JSD_GetThisForStackFrame (mCx, mThreadState,
 
1861
                                               mStackFrameInfo);
 
1862
    
 
1863
    *_rval = jsdValue::FromPtr (mCx, jsdv);
 
1864
    return NS_OK;
 
1865
}
 
1866
 
 
1867
 
 
1868
NS_IMETHODIMP
 
1869
jsdStackFrame::Eval (const nsAString &bytes, const char *fileName,
 
1870
                     PRUint32 line, jsdIValue **result, PRBool *_rval)
 
1871
{
 
1872
    ASSERT_VALID_EPHEMERAL;
 
1873
 
 
1874
    if (bytes.IsEmpty())
 
1875
        return NS_ERROR_INVALID_ARG;
 
1876
 
 
1877
    // get pointer to buffer contained in |bytes|
 
1878
    nsAString::const_iterator h;
 
1879
    bytes.BeginReading(h);
 
1880
    const jschar *char_bytes = NS_REINTERPRET_CAST(const jschar *, h.get());
 
1881
 
 
1882
    JSExceptionState *estate = 0;
 
1883
    jsval jv;
 
1884
 
 
1885
    JSContext *cx = JSD_GetJSContext (mCx, mThreadState);
 
1886
    estate = JS_SaveExceptionState (cx);
 
1887
    JS_ClearPendingException (cx);
 
1888
 
 
1889
    *_rval = JSD_AttemptUCScriptInStackFrame (mCx, mThreadState,
 
1890
                                              mStackFrameInfo,
 
1891
                                              char_bytes, bytes.Length(),
 
1892
                                              fileName, line, &jv);
 
1893
    if (!*_rval) {
 
1894
        if (JS_IsExceptionPending(cx))
 
1895
            JS_GetPendingException (cx, &jv);
 
1896
        else
 
1897
            jv = 0;
 
1898
    }
 
1899
 
 
1900
    JS_RestoreExceptionState (cx, estate);
 
1901
    JSDValue *jsdv = JSD_NewValue (mCx, jv);
 
1902
    if (!jsdv)
 
1903
        return NS_ERROR_FAILURE;
 
1904
    *result = jsdValue::FromPtr (mCx, jsdv);
 
1905
    if (!*result)
 
1906
        return NS_ERROR_FAILURE;
 
1907
    
 
1908
    return NS_OK;
 
1909
}        
 
1910
 
 
1911
/* Values */
 
1912
NS_IMPL_THREADSAFE_ISUPPORTS2(jsdValue, jsdIValue, jsdIEphemeral)
 
1913
jsdIValue *
 
1914
jsdValue::FromPtr (JSDContext *aCx, JSDValue *aValue)
 
1915
{
 
1916
    /* value will be dropped by te jsdValue destructor. */
 
1917
 
 
1918
    if (!aValue)
 
1919
        return nsnull;
 
1920
    
 
1921
    jsdIValue *rv = new jsdValue (aCx, aValue);
 
1922
    NS_IF_ADDREF(rv);
 
1923
    return rv;
 
1924
}
 
1925
 
 
1926
jsdValue::jsdValue (JSDContext *aCx, JSDValue *aValue) : mValid(PR_TRUE),
 
1927
                                                         mCx(aCx), 
 
1928
                                                         mValue(aValue)
 
1929
{
 
1930
    DEBUG_CREATE ("jsdValue", gValueCount);
 
1931
    mLiveListEntry.value = this;
 
1932
    jsds_InsertEphemeral (&gLiveValues, &mLiveListEntry);
 
1933
}
 
1934
 
 
1935
jsdValue::~jsdValue() 
 
1936
{
 
1937
    DEBUG_DESTROY ("jsdValue", gValueCount);
 
1938
    if (mValid)
 
1939
        /* call Invalidate() to take ourselves out of the live list */
 
1940
        Invalidate();
 
1941
}   
 
1942
 
 
1943
NS_IMETHODIMP
 
1944
jsdValue::GetIsValid(PRBool *_rval)
 
1945
{
 
1946
    *_rval = mValid;
 
1947
    return NS_OK;
 
1948
}
 
1949
 
 
1950
NS_IMETHODIMP
 
1951
jsdValue::Invalidate()
 
1952
{
 
1953
    ASSERT_VALID_EPHEMERAL;
 
1954
    mValid = PR_FALSE;
 
1955
    jsds_RemoveEphemeral (&gLiveValues, &mLiveListEntry);
 
1956
    JSD_DropValue (mCx, mValue);
 
1957
    return NS_OK;
 
1958
}
 
1959
 
 
1960
void
 
1961
jsdValue::InvalidateAll()
 
1962
{
 
1963
    if (gLiveValues)
 
1964
        jsds_InvalidateAllEphemerals (&gLiveValues);
 
1965
}
 
1966
 
 
1967
NS_IMETHODIMP
 
1968
jsdValue::GetJSDContext(JSDContext **_rval)
 
1969
{
 
1970
    ASSERT_VALID_EPHEMERAL;
 
1971
    *_rval = mCx;
 
1972
    return NS_OK;
 
1973
}
 
1974
 
 
1975
NS_IMETHODIMP
 
1976
jsdValue::GetJSDValue (JSDValue **_rval)
 
1977
{
 
1978
    ASSERT_VALID_EPHEMERAL;
 
1979
    *_rval = mValue;
 
1980
    return NS_OK;
 
1981
}
 
1982
 
 
1983
NS_IMETHODIMP
 
1984
jsdValue::GetIsNative (PRBool *_rval)
 
1985
{
 
1986
    ASSERT_VALID_EPHEMERAL;
 
1987
    *_rval = JSD_IsValueNative (mCx, mValue);
 
1988
    return NS_OK;
 
1989
}
 
1990
 
 
1991
NS_IMETHODIMP
 
1992
jsdValue::GetIsNumber (PRBool *_rval)
 
1993
{
 
1994
    ASSERT_VALID_EPHEMERAL;
 
1995
    *_rval = JSD_IsValueNumber (mCx, mValue);
 
1996
    return NS_OK;
 
1997
}
 
1998
 
 
1999
NS_IMETHODIMP
 
2000
jsdValue::GetIsPrimitive (PRBool *_rval)
 
2001
{
 
2002
    ASSERT_VALID_EPHEMERAL;
 
2003
    *_rval = JSD_IsValuePrimitive (mCx, mValue);
 
2004
    return NS_OK;
 
2005
}
 
2006
 
 
2007
NS_IMETHODIMP
 
2008
jsdValue::GetJsType (PRUint32 *_rval)
 
2009
{
 
2010
    ASSERT_VALID_EPHEMERAL;
 
2011
    jsval val;
 
2012
 
 
2013
    val = JSD_GetValueWrappedJSVal (mCx, mValue);
 
2014
    
 
2015
    if (JSVAL_IS_NULL(val))
 
2016
        *_rval = TYPE_NULL;
 
2017
    else if (JSVAL_IS_BOOLEAN(val))
 
2018
        *_rval = TYPE_BOOLEAN;
 
2019
    else if (JSVAL_IS_DOUBLE(val))
 
2020
        *_rval = TYPE_DOUBLE;
 
2021
    else if (JSVAL_IS_INT(val))
 
2022
        *_rval = TYPE_INT;
 
2023
    else if (JSVAL_IS_STRING(val))
 
2024
        *_rval = TYPE_STRING;
 
2025
    else if (JSVAL_IS_VOID(val))
 
2026
        *_rval = TYPE_VOID;
 
2027
    else if (JSD_IsValueFunction (mCx, mValue))
 
2028
        *_rval = TYPE_FUNCTION;
 
2029
    else if (JSVAL_IS_OBJECT(val))
 
2030
        *_rval = TYPE_OBJECT;
 
2031
    else
 
2032
        NS_ASSERTION (0, "Value has no discernible type.");
 
2033
 
 
2034
    return NS_OK;
 
2035
}
 
2036
 
 
2037
NS_IMETHODIMP
 
2038
jsdValue::GetJsPrototype (jsdIValue **_rval)
 
2039
{
 
2040
    ASSERT_VALID_EPHEMERAL;
 
2041
    JSDValue *jsdv = JSD_GetValuePrototype (mCx, mValue);
 
2042
    *_rval = jsdValue::FromPtr (mCx, jsdv);
 
2043
    return NS_OK;
 
2044
}
 
2045
 
 
2046
NS_IMETHODIMP
 
2047
jsdValue::GetJsParent (jsdIValue **_rval)
 
2048
{
 
2049
    ASSERT_VALID_EPHEMERAL;
 
2050
    JSDValue *jsdv = JSD_GetValueParent (mCx, mValue);
 
2051
    *_rval = jsdValue::FromPtr (mCx, jsdv);
 
2052
    return NS_OK;
 
2053
}
 
2054
 
 
2055
NS_IMETHODIMP
 
2056
jsdValue::GetJsClassName(char **_rval)
 
2057
{
 
2058
    ASSERT_VALID_EPHEMERAL;
 
2059
    const char *name = JSD_GetValueClassName(mCx, mValue);
 
2060
    if (name) {
 
2061
        *_rval = PL_strdup(name);
 
2062
        if (!*_rval)
 
2063
            return NS_ERROR_OUT_OF_MEMORY;
 
2064
    } else {
 
2065
        *_rval = nsnull;
 
2066
    }
 
2067
    
 
2068
    return NS_OK;
 
2069
}
 
2070
 
 
2071
NS_IMETHODIMP
 
2072
jsdValue::GetJsConstructor (jsdIValue **_rval)
 
2073
{
 
2074
    ASSERT_VALID_EPHEMERAL;
 
2075
    JSDValue *jsdv = JSD_GetValueConstructor (mCx, mValue);
 
2076
    *_rval = jsdValue::FromPtr (mCx, jsdv);
 
2077
    return NS_OK;
 
2078
}
 
2079
 
 
2080
NS_IMETHODIMP
 
2081
jsdValue::GetJsFunctionName(char **_rval)
 
2082
{
 
2083
    ASSERT_VALID_EPHEMERAL;
 
2084
    const char *name = JSD_GetValueFunctionName(mCx, mValue);
 
2085
    if (name) {
 
2086
        *_rval = PL_strdup(name);
 
2087
        if (!*_rval)
 
2088
            return NS_ERROR_OUT_OF_MEMORY;
 
2089
    } else {
 
2090
        /* top level scripts have no function name */
 
2091
        *_rval = nsnull;
 
2092
        return NS_OK;
 
2093
    }
 
2094
 
 
2095
    return NS_OK;
 
2096
}
 
2097
 
 
2098
NS_IMETHODIMP
 
2099
jsdValue::GetBooleanValue(PRBool *_rval)
 
2100
{
 
2101
    ASSERT_VALID_EPHEMERAL;
 
2102
    *_rval = JSD_GetValueBoolean (mCx, mValue);
 
2103
    return NS_OK;
 
2104
}
 
2105
 
 
2106
NS_IMETHODIMP
 
2107
jsdValue::GetDoubleValue(double *_rval)
 
2108
{
 
2109
    ASSERT_VALID_EPHEMERAL;
 
2110
    double *dp = JSD_GetValueDouble (mCx, mValue);
 
2111
    if (!dp)
 
2112
        return NS_ERROR_FAILURE;
 
2113
    *_rval = *dp;
 
2114
    return NS_OK;
 
2115
}
 
2116
 
 
2117
NS_IMETHODIMP
 
2118
jsdValue::GetIntValue(PRInt32 *_rval)
 
2119
{
 
2120
    ASSERT_VALID_EPHEMERAL;
 
2121
    *_rval = JSD_GetValueInt (mCx, mValue);
 
2122
    return NS_OK;
 
2123
}
 
2124
 
 
2125
NS_IMETHODIMP
 
2126
jsdValue::GetObjectValue(jsdIObject **_rval)
 
2127
{
 
2128
    ASSERT_VALID_EPHEMERAL;
 
2129
    JSDObject *obj;
 
2130
    obj = JSD_GetObjectForValue (mCx, mValue);
 
2131
    *_rval = jsdObject::FromPtr (mCx, obj);
 
2132
    if (!*_rval)
 
2133
        return NS_ERROR_FAILURE;
 
2134
    return NS_OK;
 
2135
}
 
2136
    
 
2137
NS_IMETHODIMP
 
2138
jsdValue::GetStringValue(char **_rval)
 
2139
{
 
2140
    ASSERT_VALID_EPHEMERAL;
 
2141
    JSString *jstr_val = JSD_GetValueString(mCx, mValue);
 
2142
    if (jstr_val) {
 
2143
        char *bytes = JS_GetStringBytes(jstr_val);
 
2144
        *_rval = PL_strdup(bytes);
 
2145
        if (!*_rval)
 
2146
            return NS_ERROR_OUT_OF_MEMORY;
 
2147
    } else {
 
2148
        *_rval = nsnull;
 
2149
    }
 
2150
    return NS_OK;
 
2151
}
 
2152
 
 
2153
NS_IMETHODIMP
 
2154
jsdValue::GetPropertyCount (PRInt32 *_rval)
 
2155
{
 
2156
    ASSERT_VALID_EPHEMERAL;
 
2157
    if (JSD_IsValueObject(mCx, mValue))
 
2158
        *_rval = JSD_GetCountOfProperties (mCx, mValue);
 
2159
    else
 
2160
        *_rval = -1;
 
2161
    return NS_OK;
 
2162
}
 
2163
 
 
2164
NS_IMETHODIMP
 
2165
jsdValue::GetProperties (jsdIProperty ***propArray, PRUint32 *length)
 
2166
{
 
2167
    ASSERT_VALID_EPHEMERAL;
 
2168
    if (!JSD_IsValueObject(mCx, mValue)) {
 
2169
        *length = 0;
 
2170
        *propArray = 0;
 
2171
        return NS_OK;
 
2172
    }
 
2173
 
 
2174
    jsdIProperty **pa_temp;
 
2175
    PRUint32 prop_count = JSD_GetCountOfProperties (mCx, mValue);
 
2176
    
 
2177
    pa_temp = NS_STATIC_CAST(jsdIProperty **,
 
2178
                             nsMemory::Alloc(sizeof (jsdIProperty *) * 
 
2179
                                             prop_count));
 
2180
 
 
2181
    PRUint32     i    = 0;
 
2182
    JSDProperty *iter = NULL;
 
2183
    JSDProperty *prop;
 
2184
    while ((prop = JSD_IterateProperties (mCx, mValue, &iter))) {
 
2185
        pa_temp[i] = jsdProperty::FromPtr (mCx, prop);
 
2186
        ++i;
 
2187
    }
 
2188
    
 
2189
    NS_ASSERTION (prop_count == i, "property count mismatch");    
 
2190
 
 
2191
    /* if caller doesn't care about length, don't bother telling them */
 
2192
    *propArray = pa_temp;
 
2193
    if (length)
 
2194
        *length = prop_count;
 
2195
    
 
2196
    return NS_OK;
 
2197
}
 
2198
 
 
2199
NS_IMETHODIMP
 
2200
jsdValue::GetProperty (const char *name, jsdIProperty **_rval)
 
2201
{
 
2202
    ASSERT_VALID_EPHEMERAL;
 
2203
    JSContext *cx = JSD_GetDefaultJSContext (mCx);
 
2204
    /* not rooting this */
 
2205
    JSString *jstr_name = JS_NewStringCopyZ (cx, name);
 
2206
 
 
2207
    JSDProperty *prop = JSD_GetValueProperty (mCx, mValue, jstr_name);
 
2208
    
 
2209
    *_rval = jsdProperty::FromPtr (mCx, prop);
 
2210
    return NS_OK;
 
2211
}
 
2212
 
 
2213
NS_IMETHODIMP
 
2214
jsdValue::Refresh()
 
2215
{
 
2216
    ASSERT_VALID_EPHEMERAL;
 
2217
    JSD_RefreshValue (mCx, mValue);
 
2218
    return NS_OK;
 
2219
}
 
2220
 
 
2221
NS_IMETHODIMP
 
2222
jsdValue::GetWrappedValue()
 
2223
{
 
2224
    ASSERT_VALID_EPHEMERAL;
 
2225
    nsCOMPtr<nsIXPConnect> xpc = do_GetService(nsIXPConnect::GetCID());
 
2226
    if (!xpc)
 
2227
        return NS_ERROR_FAILURE;
 
2228
 
 
2229
    nsresult rv;
 
2230
    nsCOMPtr<nsIXPCNativeCallContext> cc;
 
2231
    rv = xpc->GetCurrentNativeCallContext(getter_AddRefs(cc));
 
2232
    if (NS_FAILED(rv))
 
2233
        return rv;
 
2234
 
 
2235
    jsval *result;
 
2236
    rv = cc->GetRetValPtr(&result);
 
2237
    if (NS_FAILED(rv))
 
2238
        return rv;
 
2239
 
 
2240
    if (result)
 
2241
    {
 
2242
        *result = JSD_GetValueWrappedJSVal (mCx, mValue);
 
2243
        cc->SetReturnValueWasSet(PR_TRUE);
 
2244
    }
 
2245
 
 
2246
    return NS_OK;
 
2247
}
 
2248
 
 
2249
/******************************************************************************
 
2250
 * debugger service implementation
 
2251
 ******************************************************************************/
 
2252
NS_IMPL_THREADSAFE_ISUPPORTS1(jsdService, jsdIDebuggerService)
 
2253
 
 
2254
NS_IMETHODIMP
 
2255
jsdService::GetJSDContext(JSDContext **_rval)
 
2256
{
 
2257
    *_rval = mCx;
 
2258
    return NS_OK;
 
2259
}
 
2260
 
 
2261
NS_IMETHODIMP
 
2262
jsdService::GetInitAtStartup (PRBool *_rval)
 
2263
{
 
2264
    nsresult rv;
 
2265
    nsCOMPtr<nsICategoryManager>
 
2266
        categoryManager(do_GetService(NS_CATMAN_CTRID, &rv));
 
2267
    
 
2268
    if (NS_FAILED(rv))
 
2269
    {
 
2270
        NS_WARNING("couldn't get category manager");
 
2271
        return rv;
 
2272
    }
 
2273
 
 
2274
    if (mInitAtStartup == triUnknown) {
 
2275
        nsXPIDLCString notused;
 
2276
        nsresult autoreg_rv, appstart_rv;
 
2277
        
 
2278
        autoreg_rv = categoryManager->GetCategoryEntry(AUTOREG_CATEGORY, 
 
2279
                                                       JSD_AUTOREG_ENTRY,
 
2280
                                                       getter_Copies(notused));
 
2281
        appstart_rv = categoryManager->GetCategoryEntry(APPSTART_CATEGORY,
 
2282
                                                        JSD_STARTUP_ENTRY,
 
2283
                                                        getter_Copies(notused));
 
2284
        if (autoreg_rv != appstart_rv) {
 
2285
            /* we have an inconsistent state in the registry, attempt to fix.
 
2286
             * we need to make mInitAtStartup disagree with the state passed
 
2287
             * to SetInitAtStartup to make it actually do something.
 
2288
             */
 
2289
            mInitAtStartup = triYes;
 
2290
            rv = SetInitAtStartup (PR_FALSE);
 
2291
            if (NS_FAILED(rv))
 
2292
            {
 
2293
                NS_WARNING("SetInitAtStartup failed");
 
2294
                return rv;
 
2295
            }
 
2296
        } else if (autoreg_rv == NS_ERROR_NOT_AVAILABLE) {
 
2297
            mInitAtStartup = triNo;
 
2298
        } else if (NS_SUCCEEDED(autoreg_rv)) {
 
2299
            mInitAtStartup = triYes;
 
2300
        } else {
 
2301
            NS_WARN_IF_FALSE(NS_SUCCEEDED(autoreg_rv),
 
2302
                             "couldn't get autoreg category");
 
2303
            NS_WARN_IF_FALSE(NS_SUCCEEDED(appstart_rv),
 
2304
                             "couldn't get appstart category");
 
2305
            return rv;
 
2306
        }
 
2307
    }
 
2308
    
 
2309
    if (_rval)
 
2310
        *_rval = (mInitAtStartup == triYes);
 
2311
 
 
2312
    return NS_OK;
 
2313
}
 
2314
 
 
2315
/*
 
2316
 * The initAtStartup property controls whether or not we register the
 
2317
 * app start observer (jsdASObserver.)  We register for both 
 
2318
 * "xpcom-autoregistration" and "app-startup" notifications if |state| is true.
 
2319
 * the autoreg message is sent just before registration occurs (before
 
2320
 * "app-startup".)  We care about autoreg because it may load javascript
 
2321
 * components.  autoreg does *not* fire if components haven't changed since the
 
2322
 * last autoreg, so we watch "app-startup" as a fallback.
 
2323
 */
 
2324
NS_IMETHODIMP
 
2325
jsdService::SetInitAtStartup (PRBool state)
 
2326
{ 
 
2327
    nsresult rv;
 
2328
 
 
2329
    if (mInitAtStartup == triUnknown) {
 
2330
        /* side effect sets mInitAtStartup */
 
2331
        rv = GetInitAtStartup(nsnull);
 
2332
        if (NS_FAILED(rv))
 
2333
            return rv;
 
2334
    }
 
2335
 
 
2336
    if (state && mInitAtStartup == triYes ||
 
2337
        !state && mInitAtStartup == triNo) {
 
2338
        /* already in the requested state */
 
2339
        return NS_OK;
 
2340
    }
 
2341
    
 
2342
    nsCOMPtr<nsICategoryManager>
 
2343
        categoryManager(do_GetService(NS_CATMAN_CTRID, &rv));
 
2344
 
 
2345
    if (state) {
 
2346
        rv = categoryManager->AddCategoryEntry(AUTOREG_CATEGORY,
 
2347
                                               JSD_AUTOREG_ENTRY,
 
2348
                                               jsdASObserverCtrID,
 
2349
                                               PR_TRUE, PR_TRUE, nsnull);
 
2350
        if (NS_FAILED(rv))
 
2351
            return rv;
 
2352
        rv = categoryManager->AddCategoryEntry(APPSTART_CATEGORY,
 
2353
                                               JSD_STARTUP_ENTRY,
 
2354
                                               jsdASObserverCtrID,
 
2355
                                               PR_TRUE, PR_TRUE, nsnull);
 
2356
        if (NS_FAILED(rv))
 
2357
            return rv;
 
2358
        mInitAtStartup = triYes;
 
2359
    } else {
 
2360
        rv = categoryManager->DeleteCategoryEntry(AUTOREG_CATEGORY,
 
2361
                                                  JSD_AUTOREG_ENTRY, PR_TRUE);
 
2362
        if (NS_FAILED(rv))
 
2363
            return rv;
 
2364
        rv = categoryManager->DeleteCategoryEntry(APPSTART_CATEGORY,
 
2365
                                                  JSD_STARTUP_ENTRY, PR_TRUE);
 
2366
        if (NS_FAILED(rv))
 
2367
            return rv;
 
2368
        mInitAtStartup = triNo;
 
2369
    }
 
2370
 
 
2371
    return NS_OK;
 
2372
}
 
2373
 
 
2374
NS_IMETHODIMP
 
2375
jsdService::GetFlags (PRUint32 *_rval)
 
2376
{
 
2377
    *_rval = JSD_GetContextFlags (mCx);
 
2378
    return NS_OK;
 
2379
}
 
2380
 
 
2381
NS_IMETHODIMP
 
2382
jsdService::SetFlags (PRUint32 flags)
 
2383
{
 
2384
    JSD_SetContextFlags (mCx, flags);
 
2385
    return NS_OK;
 
2386
}
 
2387
 
 
2388
NS_IMETHODIMP
 
2389
jsdService::GetImplementationString(char **_rval)
 
2390
{
 
2391
    *_rval = PL_strdup(implementationString);
 
2392
    if (!*_rval)
 
2393
        return NS_ERROR_OUT_OF_MEMORY;
 
2394
    return NS_OK;
 
2395
}
 
2396
 
 
2397
NS_IMETHODIMP
 
2398
jsdService::GetImplementationMajor(PRUint32 *_rval)
 
2399
{
 
2400
    *_rval = JSDS_MAJOR_VERSION;
 
2401
    return NS_OK;
 
2402
}
 
2403
 
 
2404
NS_IMETHODIMP
 
2405
jsdService::GetImplementationMinor(PRUint32 *_rval)
 
2406
{
 
2407
    *_rval = JSDS_MINOR_VERSION;
 
2408
    return NS_OK;
 
2409
}
 
2410
 
 
2411
NS_IMETHODIMP
 
2412
jsdService::GetIsOn (PRBool *_rval)
 
2413
{
 
2414
    *_rval = mOn;
 
2415
    return NS_OK;
 
2416
}
 
2417
 
 
2418
NS_IMETHODIMP
 
2419
jsdService::On (void)
 
2420
{
 
2421
    nsresult  rv;
 
2422
 
 
2423
    /* get JS things from the CallContext */
 
2424
    nsCOMPtr<nsIXPConnect> xpc = do_GetService(nsIXPConnect::GetCID());
 
2425
    if (!xpc) return NS_ERROR_FAILURE;
 
2426
 
 
2427
    nsCOMPtr<nsIXPCNativeCallContext> cc;
 
2428
    rv = xpc->GetCurrentNativeCallContext(getter_AddRefs(cc));
 
2429
    if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
 
2430
 
 
2431
    JSContext *cx;
 
2432
    rv = cc->GetJSContext (&cx);
 
2433
    if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
 
2434
    
 
2435
    return OnForRuntime(JS_GetRuntime (cx));
 
2436
    
 
2437
}
 
2438
 
 
2439
NS_IMETHODIMP
 
2440
jsdService::OnForRuntime (JSRuntime *rt)
 
2441
{
 
2442
    if (mOn)
 
2443
        return (rt == mRuntime) ? NS_OK : NS_ERROR_ALREADY_INITIALIZED;
 
2444
 
 
2445
    mRuntime = rt;
 
2446
 
 
2447
    if (gLastGCProc == jsds_GCCallbackProc)
 
2448
        /* condition indicates that the callback proc has not been set yet */
 
2449
        gLastGCProc = JS_SetGCCallbackRT (rt, jsds_GCCallbackProc);
 
2450
 
 
2451
    mCx = JSD_DebuggerOnForUser (rt, NULL, NULL);
 
2452
    if (!mCx)
 
2453
        return NS_ERROR_FAILURE;
 
2454
 
 
2455
    JSContext *cx   = JSD_GetDefaultJSContext (mCx);
 
2456
    JSObject  *glob = JS_GetGlobalObject (cx);
 
2457
 
 
2458
    /* init xpconnect on the debugger's context in case xpconnect tries to
 
2459
     * use it for stuff. */
 
2460
    nsCOMPtr<nsIXPConnect> xpc = do_GetService(nsIXPConnect::GetCID());
 
2461
    if (!xpc)
 
2462
        return NS_ERROR_FAILURE;
 
2463
    
 
2464
    xpc->InitClasses (cx, glob);
 
2465
    
 
2466
    /* If any of these mFooHook objects are installed, do the required JSD
 
2467
     * hookup now.   See also, jsdService::SetFooHook().
 
2468
     */
 
2469
    if (mErrorHook)
 
2470
        JSD_SetErrorReporter (mCx, jsds_ErrorHookProc, NULL);
 
2471
    if (mThrowHook)
 
2472
        JSD_SetThrowHook (mCx, jsds_ExecutionHookProc, NULL);
 
2473
    /* can't ignore script callbacks, as we need to |Release| the wrapper 
 
2474
     * stored in private data when a script is deleted. */
 
2475
    if (mInterruptHook)
 
2476
        JSD_SetInterruptHook (mCx, jsds_ExecutionHookProc, NULL);
 
2477
    if (mDebuggerHook)
 
2478
        JSD_SetDebuggerHook (mCx, jsds_ExecutionHookProc, NULL);
 
2479
    if (mDebugHook)
 
2480
        JSD_SetDebugBreakHook (mCx, jsds_ExecutionHookProc, NULL);
 
2481
    if (mTopLevelHook)
 
2482
        JSD_SetTopLevelHook (mCx, jsds_CallHookProc, NULL);
 
2483
    else
 
2484
        JSD_ClearTopLevelHook (mCx);
 
2485
    if (mFunctionHook)
 
2486
        JSD_SetFunctionHook (mCx, jsds_CallHookProc, NULL);
 
2487
    else
 
2488
        JSD_ClearFunctionHook (mCx);
 
2489
    mOn = PR_TRUE;
 
2490
 
 
2491
#ifdef DEBUG
 
2492
    printf ("+++ JavaScript debugging hooks installed.\n");
 
2493
#endif
 
2494
    return NS_OK;
 
2495
}
 
2496
 
 
2497
NS_IMETHODIMP
 
2498
jsdService::Off (void)
 
2499
{
 
2500
    if (!mOn)
 
2501
        return NS_OK;
 
2502
    
 
2503
    if (!mCx || !mRuntime)
 
2504
        return NS_ERROR_NOT_INITIALIZED;
 
2505
    
 
2506
    if (gDeadScripts) {
 
2507
        if (gGCStatus == JSGC_END)
 
2508
        {
 
2509
            JSContext *cx = JSD_GetDefaultJSContext(mCx);
 
2510
            jsds_NotifyPendingDeadScripts(cx);
 
2511
        }
 
2512
        else
 
2513
            return NS_ERROR_NOT_AVAILABLE;
 
2514
    }
 
2515
 
 
2516
    /*
 
2517
    if (gLastGCProc != jsds_GCCallbackProc)
 
2518
        JS_SetGCCallbackRT (mRuntime, gLastGCProc);
 
2519
    */
 
2520
 
 
2521
    jsdContext::InvalidateAll();
 
2522
    jsdScript::InvalidateAll();
 
2523
    jsdValue::InvalidateAll();
 
2524
    jsdProperty::InvalidateAll();
 
2525
    ClearAllBreakpoints();
 
2526
 
 
2527
    JSD_SetErrorReporter (mCx, NULL, NULL);
 
2528
    JSD_ClearThrowHook (mCx);
 
2529
    JSD_ClearInterruptHook (mCx);
 
2530
    JSD_ClearDebuggerHook (mCx);
 
2531
    JSD_ClearDebugBreakHook (mCx);
 
2532
    JSD_ClearTopLevelHook (mCx);
 
2533
    JSD_ClearFunctionHook (mCx);
 
2534
    
 
2535
    JSD_DebuggerOff (mCx);
 
2536
 
 
2537
    mCx = nsnull;
 
2538
    mRuntime = nsnull;
 
2539
    mOn = PR_FALSE;
 
2540
 
 
2541
#ifdef DEBUG
 
2542
    printf ("+++ JavaScript debugging hooks removed.\n");
 
2543
#endif
 
2544
 
 
2545
    return NS_OK;
 
2546
}
 
2547
 
 
2548
NS_IMETHODIMP
 
2549
jsdService::GetPauseDepth(PRUint32 *_rval)
 
2550
{
 
2551
    NS_ENSURE_ARG_POINTER(_rval);
 
2552
    *_rval = mPauseLevel;
 
2553
    return NS_OK;
 
2554
}
 
2555
    
 
2556
NS_IMETHODIMP
 
2557
jsdService::Pause(PRUint32 *_rval)
 
2558
{
 
2559
    if (++mPauseLevel == 1) {
 
2560
        JSD_SetErrorReporter (mCx, NULL, NULL);
 
2561
        JSD_ClearThrowHook (mCx);
 
2562
        JSD_ClearInterruptHook (mCx);
 
2563
        JSD_ClearDebuggerHook (mCx);
 
2564
        JSD_ClearDebugBreakHook (mCx);
 
2565
        JSD_ClearTopLevelHook (mCx);
 
2566
        JSD_ClearFunctionHook (mCx);
 
2567
    }
 
2568
 
 
2569
    if (_rval)
 
2570
        *_rval = mPauseLevel;
 
2571
 
 
2572
    return NS_OK;
 
2573
}
 
2574
 
 
2575
NS_IMETHODIMP
 
2576
jsdService::UnPause(PRUint32 *_rval)
 
2577
{
 
2578
    if (mPauseLevel == 0)
 
2579
        return NS_ERROR_NOT_AVAILABLE;
 
2580
 
 
2581
    /* check mOn before we muck with this stuff, it's possible the debugger
 
2582
     * was turned off while we were paused.
 
2583
     */
 
2584
    if (--mPauseLevel == 0 && mOn) {
 
2585
        if (mErrorHook)
 
2586
            JSD_SetErrorReporter (mCx, jsds_ErrorHookProc, NULL);
 
2587
        if (mThrowHook)
 
2588
            JSD_SetThrowHook (mCx, jsds_ExecutionHookProc, NULL);
 
2589
        if (mInterruptHook)
 
2590
            JSD_SetInterruptHook (mCx, jsds_ExecutionHookProc, NULL);
 
2591
        if (mDebuggerHook)
 
2592
            JSD_SetDebuggerHook (mCx, jsds_ExecutionHookProc, NULL);
 
2593
        if (mDebugHook)
 
2594
            JSD_SetDebugBreakHook (mCx, jsds_ExecutionHookProc, NULL);
 
2595
        if (mTopLevelHook)
 
2596
            JSD_SetTopLevelHook (mCx, jsds_CallHookProc, NULL);
 
2597
        else
 
2598
            JSD_ClearTopLevelHook (mCx);
 
2599
        if (mFunctionHook)
 
2600
            JSD_SetFunctionHook (mCx, jsds_CallHookProc, NULL);
 
2601
        else
 
2602
            JSD_ClearFunctionHook (mCx);
 
2603
    }
 
2604
    
 
2605
    if (_rval)
 
2606
        *_rval = mPauseLevel;
 
2607
 
 
2608
    return NS_OK;
 
2609
}
 
2610
 
 
2611
NS_IMETHODIMP
 
2612
jsdService::EnumerateContexts (jsdIContextEnumerator *enumerator)
 
2613
{
 
2614
    ASSERT_VALID_CONTEXT;
 
2615
    
 
2616
    if (!enumerator)
 
2617
        return NS_OK;
 
2618
    
 
2619
    JSContext *iter = NULL;
 
2620
    JSContext *cx;
 
2621
 
 
2622
    while ((cx = JS_ContextIterator (mRuntime, &iter)))
 
2623
    {
 
2624
        nsCOMPtr<jsdIContext> jsdicx = 
 
2625
            getter_AddRefs(jsdContext::FromPtr(mCx, cx));
 
2626
        if (jsdicx)
 
2627
        {
 
2628
            if (NS_FAILED(enumerator->EnumerateContext(jsdicx)))
 
2629
                break;
 
2630
        }
 
2631
    }
 
2632
 
 
2633
    return NS_OK;
 
2634
}
 
2635
 
 
2636
NS_IMETHODIMP
 
2637
jsdService::EnumerateScripts (jsdIScriptEnumerator *enumerator)
 
2638
{
 
2639
    ASSERT_VALID_CONTEXT;
 
2640
    
 
2641
    JSDScript *script;
 
2642
    JSDScript *iter = NULL;
 
2643
    nsresult rv = NS_OK;
 
2644
    
 
2645
    JSD_LockScriptSubsystem(mCx);
 
2646
    while((script = JSD_IterateScripts(mCx, &iter))) {
 
2647
        nsCOMPtr<jsdIScript> jsdis =
 
2648
            getter_AddRefs(jsdScript::FromPtr(mCx, script));
 
2649
        rv = enumerator->EnumerateScript (jsdis);
 
2650
        if (NS_FAILED(rv))
 
2651
            break;
 
2652
    }
 
2653
    JSD_UnlockScriptSubsystem(mCx);
 
2654
 
 
2655
    return rv;
 
2656
}
 
2657
 
 
2658
#ifdef GC_MARK_DEBUG
 
2659
JS_BEGIN_EXTERN_C
 
2660
JS_FRIEND_DATA(FILE *) js_DumpGCHeap;
 
2661
JS_END_EXTERN_C
 
2662
#endif
 
2663
 
 
2664
NS_IMETHODIMP
 
2665
jsdService::GC (void)
 
2666
{
 
2667
    ASSERT_VALID_CONTEXT;
 
2668
    JSContext *cx = JSD_GetDefaultJSContext (mCx);
 
2669
#ifdef GC_MARK_DEBUG
 
2670
    FILE *file = fopen("jsds-roots.txt", "w");
 
2671
    js_DumpGCHeap = file;
 
2672
#endif
 
2673
    JS_GC(cx);
 
2674
#ifdef GC_MARK_DEBUG
 
2675
    if (file)
 
2676
        fclose (file);
 
2677
    js_DumpGCHeap = NULL;
 
2678
#endif
 
2679
    return NS_OK;
 
2680
}
 
2681
    
 
2682
NS_IMETHODIMP
 
2683
jsdService::ClearProfileData ()
 
2684
{
 
2685
    ASSERT_VALID_CONTEXT;
 
2686
    JSD_ClearAllProfileData (mCx);
 
2687
    return NS_OK;
 
2688
}
 
2689
 
 
2690
NS_IMETHODIMP
 
2691
jsdService::InsertFilter (jsdIFilter *filter, jsdIFilter *after)
 
2692
{
 
2693
    NS_ENSURE_ARG_POINTER (filter);
 
2694
    if (jsds_FindFilter (filter))
 
2695
        return NS_ERROR_INVALID_ARG;
 
2696
 
 
2697
    FilterRecord *rec = PR_NEWZAP (FilterRecord);
 
2698
    if (!rec)
 
2699
        return NS_ERROR_OUT_OF_MEMORY;
 
2700
 
 
2701
    if (!jsds_SyncFilter (rec, filter)) {
 
2702
        PR_Free (rec);
 
2703
        return NS_ERROR_FAILURE;
 
2704
    }
 
2705
    
 
2706
    if (gFilters) {
 
2707
        if (!after) {
 
2708
            /* insert at head of list */
 
2709
            PR_INSERT_LINK(&rec->links, &gFilters->links);
 
2710
            gFilters = rec;
 
2711
        } else {
 
2712
            /* insert somewhere in the list */
 
2713
            FilterRecord *afterRecord = jsds_FindFilter (after);
 
2714
            if (!afterRecord) {
 
2715
                jsds_FreeFilter(rec);
 
2716
                return NS_ERROR_INVALID_ARG;
 
2717
            }
 
2718
            PR_INSERT_AFTER(&rec->links, &afterRecord->links);
 
2719
        }
 
2720
    } else {
 
2721
        if (after) {
 
2722
            /* user asked to insert into the middle of an empty list, bail. */
 
2723
            jsds_FreeFilter(rec);
 
2724
            return NS_ERROR_NOT_INITIALIZED;
 
2725
        }
 
2726
        PR_INIT_CLIST(&rec->links);
 
2727
        gFilters = rec;
 
2728
    }
 
2729
    
 
2730
    return NS_OK;
 
2731
}
 
2732
 
 
2733
NS_IMETHODIMP
 
2734
jsdService::AppendFilter (jsdIFilter *filter)
 
2735
{
 
2736
    NS_ENSURE_ARG_POINTER (filter);
 
2737
    if (jsds_FindFilter (filter))
 
2738
        return NS_ERROR_INVALID_ARG;
 
2739
    FilterRecord *rec = PR_NEWZAP (FilterRecord);
 
2740
 
 
2741
    if (!jsds_SyncFilter (rec, filter)) {
 
2742
        PR_Free (rec);
 
2743
        return NS_ERROR_FAILURE;
 
2744
    }
 
2745
    
 
2746
    if (gFilters) {
 
2747
        PR_INSERT_BEFORE(&rec->links, &gFilters->links);
 
2748
    } else {
 
2749
        PR_INIT_CLIST(&rec->links);
 
2750
        gFilters = rec;
 
2751
    }
 
2752
    
 
2753
    return NS_OK;
 
2754
}
 
2755
 
 
2756
NS_IMETHODIMP
 
2757
jsdService::RemoveFilter (jsdIFilter *filter)
 
2758
{
 
2759
    NS_ENSURE_ARG_POINTER(filter);
 
2760
    FilterRecord *rec = jsds_FindFilter (filter);
 
2761
    if (!rec)
 
2762
        return NS_ERROR_INVALID_ARG;
 
2763
    
 
2764
    if (gFilters == rec) {
 
2765
        gFilters = NS_REINTERPRET_CAST(FilterRecord *,
 
2766
                                       PR_NEXT_LINK(&rec->links));
 
2767
        /* If we're the only filter left, null out the list head. */
 
2768
        if (gFilters == rec)
 
2769
            gFilters = nsnull;
 
2770
    }
 
2771
 
 
2772
    
 
2773
    PR_REMOVE_LINK(&rec->links);
 
2774
    jsds_FreeFilter (rec);
 
2775
    
 
2776
    return NS_OK;
 
2777
}
 
2778
 
 
2779
NS_IMETHODIMP
 
2780
jsdService::SwapFilters (jsdIFilter *filter_a, jsdIFilter *filter_b)
 
2781
{
 
2782
    NS_ENSURE_ARG_POINTER(filter_a);
 
2783
    NS_ENSURE_ARG_POINTER(filter_b);
 
2784
    
 
2785
    FilterRecord *rec_a = jsds_FindFilter (filter_a);
 
2786
    if (!rec_a)
 
2787
        return NS_ERROR_INVALID_ARG;
 
2788
    
 
2789
    if (filter_a == filter_b) {
 
2790
        /* just a refresh */
 
2791
        if (!jsds_SyncFilter (rec_a, filter_a))
 
2792
            return NS_ERROR_FAILURE;
 
2793
        return NS_OK;
 
2794
    }
 
2795
    
 
2796
    FilterRecord *rec_b = jsds_FindFilter (filter_b);
 
2797
    if (!rec_b) {
 
2798
        /* filter_b is not in the list, replace filter_a with filter_b. */
 
2799
        if (!jsds_SyncFilter (rec_a, filter_b))
 
2800
            return NS_ERROR_FAILURE;
 
2801
    } else {
 
2802
        /* both filters are in the list, swap. */
 
2803
        if (!jsds_SyncFilter (rec_a, filter_b))
 
2804
            return NS_ERROR_FAILURE;
 
2805
        if (!jsds_SyncFilter (rec_b, filter_a))
 
2806
            return NS_ERROR_FAILURE;
 
2807
    }
 
2808
    
 
2809
    return NS_OK;
 
2810
}
 
2811
 
 
2812
NS_IMETHODIMP
 
2813
jsdService::EnumerateFilters (jsdIFilterEnumerator *enumerator) 
 
2814
{
 
2815
    if (!gFilters)
 
2816
        return NS_OK;
 
2817
    
 
2818
    FilterRecord *current = gFilters;
 
2819
    do {
 
2820
        jsds_SyncFilter (current, current->filterObject);
 
2821
        /* SyncFilter failure would be bad, but what would we do about it? */
 
2822
        if (enumerator) {
 
2823
            nsresult rv = enumerator->EnumerateFilter (current->filterObject);
 
2824
            if (NS_FAILED(rv))
 
2825
                return rv;
 
2826
        }
 
2827
        current = NS_REINTERPRET_CAST(FilterRecord *,
 
2828
                                      PR_NEXT_LINK (&current->links));
 
2829
    } while (current != gFilters);
 
2830
    
 
2831
    return NS_OK;
 
2832
}
 
2833
 
 
2834
NS_IMETHODIMP
 
2835
jsdService::RefreshFilters ()
 
2836
{
 
2837
    return EnumerateFilters(nsnull);
 
2838
}
 
2839
 
 
2840
NS_IMETHODIMP
 
2841
jsdService::ClearFilters ()
 
2842
{
 
2843
    if (!gFilters)
 
2844
        return NS_OK;
 
2845
 
 
2846
    FilterRecord *current = NS_REINTERPRET_CAST(FilterRecord *,
 
2847
                                                PR_NEXT_LINK (&gFilters->links));
 
2848
    do {
 
2849
        FilterRecord *next = NS_REINTERPRET_CAST(FilterRecord *,
 
2850
                                                 PR_NEXT_LINK (&current->links));
 
2851
        PR_REMOVE_AND_INIT_LINK(&current->links);
 
2852
        jsds_FreeFilter(current);
 
2853
        current = next;
 
2854
    } while (current != gFilters);
 
2855
    
 
2856
    jsds_FreeFilter(current);
 
2857
    gFilters = nsnull;
 
2858
    
 
2859
    return NS_OK;
 
2860
}
 
2861
        
 
2862
NS_IMETHODIMP
 
2863
jsdService::ClearAllBreakpoints (void)
 
2864
{
 
2865
    ASSERT_VALID_CONTEXT;
 
2866
 
 
2867
    JSD_LockScriptSubsystem(mCx);
 
2868
    JSD_ClearAllExecutionHooks (mCx);
 
2869
    JSD_UnlockScriptSubsystem(mCx);
 
2870
    return NS_OK;
 
2871
}
 
2872
 
 
2873
NS_IMETHODIMP
 
2874
jsdService::WrapValue(jsdIValue **_rval)
 
2875
{
 
2876
    ASSERT_VALID_CONTEXT;
 
2877
 
 
2878
    nsCOMPtr<nsIXPConnect> xpc = do_GetService (nsIXPConnect::GetCID());
 
2879
    if (!xpc)
 
2880
        return NS_ERROR_FAILURE;
 
2881
 
 
2882
    nsresult rv;
 
2883
    nsCOMPtr<nsIXPCNativeCallContext> cc;
 
2884
    rv = xpc->GetCurrentNativeCallContext (getter_AddRefs(cc));
 
2885
    if (NS_FAILED(rv))
 
2886
        return rv;
 
2887
 
 
2888
    PRUint32 argc;
 
2889
    rv = cc->GetArgc (&argc);
 
2890
    if (NS_FAILED(rv))
 
2891
        return rv;
 
2892
    if (argc < 1)
 
2893
        return NS_ERROR_INVALID_ARG;
 
2894
    
 
2895
    jsval    *argv;
 
2896
    rv = cc->GetArgvPtr (&argv);
 
2897
    if (NS_FAILED(rv))
 
2898
        return rv;
 
2899
 
 
2900
    JSDValue *jsdv = JSD_NewValue (mCx, argv[0]);
 
2901
    if (!jsdv)
 
2902
        return NS_ERROR_FAILURE;
 
2903
    
 
2904
    *_rval = jsdValue::FromPtr (mCx, jsdv);
 
2905
    return NS_OK;
 
2906
}
 
2907
 
 
2908
 
 
2909
NS_IMETHODIMP
 
2910
jsdService::EnterNestedEventLoop (jsdINestCallback *callback, PRUint32 *_rval)
 
2911
{
 
2912
    nsCOMPtr<nsIAppShell> appShell(do_CreateInstance(kAppShellCID));
 
2913
    NS_ENSURE_TRUE(appShell, NS_ERROR_FAILURE);
 
2914
    nsCOMPtr<nsIEventQueueService> 
 
2915
        eventService(do_GetService(kEventQueueServiceCID));
 
2916
    NS_ENSURE_TRUE(eventService, NS_ERROR_FAILURE);
 
2917
    
 
2918
    appShell->Create(0, nsnull);
 
2919
    appShell->Spinup();
 
2920
 
 
2921
    nsCOMPtr<nsIJSContextStack> 
 
2922
        stack(do_GetService("@mozilla.org/js/xpc/ContextStack;1"));
 
2923
    nsresult rv = NS_OK;
 
2924
    PRUint32 nestLevel = ++mNestedLoopLevel;
 
2925
    
 
2926
    nsCOMPtr<nsIEventQueue> eventQ;
 
2927
    if (stack && NS_SUCCEEDED(stack->Push(nsnull)) &&
 
2928
        NS_SUCCEEDED(eventService->PushThreadEventQueue(getter_AddRefs(eventQ))))
 
2929
    {
 
2930
        if (NS_SUCCEEDED(rv) && callback) {
 
2931
            Pause(nsnull);
 
2932
            rv = callback->OnNest();
 
2933
            UnPause(nsnull);
 
2934
        }
 
2935
        
 
2936
        while(NS_SUCCEEDED(rv) && mNestedLoopLevel >= nestLevel)
 
2937
        {
 
2938
            void* data;
 
2939
            PRBool isRealEvent;
 
2940
            //PRBool processEvent;
 
2941
            
 
2942
            rv = appShell->GetNativeEvent(isRealEvent, data);
 
2943
            if(NS_SUCCEEDED(rv))
 
2944
                appShell->DispatchNativeEvent(isRealEvent, data);
 
2945
            }
 
2946
        JSContext* cx;
 
2947
        stack->Pop(&cx);
 
2948
        NS_ASSERTION(cx == nsnull, "JSContextStack mismatch");
 
2949
    }
 
2950
    else
 
2951
        rv = NS_ERROR_FAILURE;
 
2952
    
 
2953
    eventService->PopThreadEventQueue(eventQ);
 
2954
    appShell->Spindown();
 
2955
 
 
2956
    NS_ASSERTION (mNestedLoopLevel <= nestLevel,
 
2957
                  "nested event didn't unwind properly");
 
2958
    if (mNestedLoopLevel == nestLevel)
 
2959
        --mNestedLoopLevel;
 
2960
 
 
2961
    *_rval = mNestedLoopLevel;
 
2962
    return rv;
 
2963
}
 
2964
 
 
2965
NS_IMETHODIMP
 
2966
jsdService::ExitNestedEventLoop (PRUint32 *_rval)
 
2967
{
 
2968
    if (mNestedLoopLevel > 0)
 
2969
        --mNestedLoopLevel;
 
2970
    else
 
2971
        return NS_ERROR_FAILURE;
 
2972
 
 
2973
    *_rval = mNestedLoopLevel;    
 
2974
    return NS_OK;
 
2975
}    
 
2976
 
 
2977
/* hook attribute get/set functions */
 
2978
 
 
2979
NS_IMETHODIMP
 
2980
jsdService::SetErrorHook (jsdIErrorHook *aHook)
 
2981
{
 
2982
    mErrorHook = aHook;
 
2983
 
 
2984
    /* if the debugger isn't initialized, that's all we can do for now.  The
 
2985
     * OnForRuntime() method will do the rest when the coast is clear.
 
2986
     */
 
2987
    if (!mCx || mPauseLevel)
 
2988
        return NS_OK;
 
2989
 
 
2990
    if (aHook)
 
2991
        JSD_SetErrorReporter (mCx, jsds_ErrorHookProc, NULL);
 
2992
    else
 
2993
        JSD_SetErrorReporter (mCx, NULL, NULL);
 
2994
 
 
2995
    return NS_OK;
 
2996
}
 
2997
 
 
2998
NS_IMETHODIMP
 
2999
jsdService::GetErrorHook (jsdIErrorHook **aHook)
 
3000
{
 
3001
    *aHook = mErrorHook;
 
3002
    NS_IF_ADDREF(*aHook);
 
3003
    
 
3004
    return NS_OK;
 
3005
}
 
3006
 
 
3007
NS_IMETHODIMP
 
3008
jsdService::SetBreakpointHook (jsdIExecutionHook *aHook)
 
3009
{    
 
3010
    mBreakpointHook = aHook;
 
3011
    return NS_OK;
 
3012
}
 
3013
 
 
3014
NS_IMETHODIMP
 
3015
jsdService::GetBreakpointHook (jsdIExecutionHook **aHook)
 
3016
{   
 
3017
    *aHook = mBreakpointHook;
 
3018
    NS_IF_ADDREF(*aHook);
 
3019
    
 
3020
    return NS_OK;
 
3021
}
 
3022
 
 
3023
NS_IMETHODIMP
 
3024
jsdService::SetDebugHook (jsdIExecutionHook *aHook)
 
3025
{    
 
3026
    mDebugHook = aHook;
 
3027
 
 
3028
    /* if the debugger isn't initialized, that's all we can do for now.  The
 
3029
     * OnForRuntime() method will do the rest when the coast is clear.
 
3030
     */
 
3031
    if (!mCx || mPauseLevel)
 
3032
        return NS_OK;
 
3033
 
 
3034
    if (aHook)
 
3035
        JSD_SetDebugBreakHook (mCx, jsds_ExecutionHookProc, NULL);
 
3036
    else
 
3037
        JSD_ClearDebugBreakHook (mCx);
 
3038
    
 
3039
    return NS_OK;
 
3040
}
 
3041
 
 
3042
NS_IMETHODIMP
 
3043
jsdService::GetDebugHook (jsdIExecutionHook **aHook)
 
3044
{   
 
3045
    *aHook = mDebugHook;
 
3046
    NS_IF_ADDREF(*aHook);
 
3047
    
 
3048
    return NS_OK;
 
3049
}
 
3050
 
 
3051
NS_IMETHODIMP
 
3052
jsdService::SetDebuggerHook (jsdIExecutionHook *aHook)
 
3053
{    
 
3054
    mDebuggerHook = aHook;
 
3055
 
 
3056
    /* if the debugger isn't initialized, that's all we can do for now.  The
 
3057
     * OnForRuntime() method will do the rest when the coast is clear.
 
3058
     */
 
3059
    if (!mCx || mPauseLevel)
 
3060
        return NS_OK;
 
3061
 
 
3062
    if (aHook)
 
3063
        JSD_SetDebuggerHook (mCx, jsds_ExecutionHookProc, NULL);
 
3064
    else
 
3065
        JSD_ClearDebuggerHook (mCx);
 
3066
    
 
3067
    return NS_OK;
 
3068
}
 
3069
 
 
3070
NS_IMETHODIMP
 
3071
jsdService::GetDebuggerHook (jsdIExecutionHook **aHook)
 
3072
{   
 
3073
    *aHook = mDebuggerHook;
 
3074
    NS_IF_ADDREF(*aHook);
 
3075
    
 
3076
    return NS_OK;
 
3077
}
 
3078
 
 
3079
NS_IMETHODIMP
 
3080
jsdService::SetInterruptHook (jsdIExecutionHook *aHook)
 
3081
{    
 
3082
    mInterruptHook = aHook;
 
3083
 
 
3084
    /* if the debugger isn't initialized, that's all we can do for now.  The
 
3085
     * OnForRuntime() method will do the rest when the coast is clear.
 
3086
     */
 
3087
    if (!mCx || mPauseLevel)
 
3088
        return NS_OK;
 
3089
 
 
3090
    if (aHook)
 
3091
        JSD_SetInterruptHook (mCx, jsds_ExecutionHookProc, NULL);
 
3092
    else
 
3093
        JSD_ClearInterruptHook (mCx);
 
3094
    
 
3095
    return NS_OK;
 
3096
}
 
3097
 
 
3098
NS_IMETHODIMP
 
3099
jsdService::GetInterruptHook (jsdIExecutionHook **aHook)
 
3100
{   
 
3101
    *aHook = mInterruptHook;
 
3102
    NS_IF_ADDREF(*aHook);
 
3103
    
 
3104
    return NS_OK;
 
3105
}
 
3106
 
 
3107
NS_IMETHODIMP
 
3108
jsdService::SetScriptHook (jsdIScriptHook *aHook)
 
3109
{    
 
3110
    mScriptHook = aHook;
 
3111
 
 
3112
    /* if the debugger isn't initialized, that's all we can do for now.  The
 
3113
     * OnForRuntime() method will do the rest when the coast is clear.
 
3114
     */
 
3115
    if (!mCx || mPauseLevel)
 
3116
        return NS_OK;
 
3117
    
 
3118
    if (aHook)
 
3119
        JSD_SetScriptHook (mCx, jsds_ScriptHookProc, NULL);
 
3120
    /* we can't unset it if !aHook, because we still need to see script
 
3121
     * deletes in order to Release the jsdIScripts held in JSDScript
 
3122
     * private data. */
 
3123
    return NS_OK;
 
3124
}
 
3125
 
 
3126
NS_IMETHODIMP
 
3127
jsdService::GetScriptHook (jsdIScriptHook **aHook)
 
3128
{   
 
3129
    *aHook = mScriptHook;
 
3130
    NS_IF_ADDREF(*aHook);
 
3131
    
 
3132
    return NS_OK;
 
3133
}
 
3134
 
 
3135
NS_IMETHODIMP
 
3136
jsdService::SetThrowHook (jsdIExecutionHook *aHook)
 
3137
{    
 
3138
    mThrowHook = aHook;
 
3139
 
 
3140
    /* if the debugger isn't initialized, that's all we can do for now.  The
 
3141
     * OnForRuntime() method will do the rest when the coast is clear.
 
3142
     */
 
3143
    if (!mCx || mPauseLevel)
 
3144
        return NS_OK;
 
3145
 
 
3146
    if (aHook)
 
3147
        JSD_SetThrowHook (mCx, jsds_ExecutionHookProc, NULL);
 
3148
    else
 
3149
        JSD_ClearThrowHook (mCx);
 
3150
    
 
3151
    return NS_OK;
 
3152
}
 
3153
 
 
3154
NS_IMETHODIMP
 
3155
jsdService::GetThrowHook (jsdIExecutionHook **aHook)
 
3156
{   
 
3157
    *aHook = mThrowHook;
 
3158
    NS_IF_ADDREF(*aHook);
 
3159
    
 
3160
    return NS_OK;
 
3161
}
 
3162
 
 
3163
NS_IMETHODIMP
 
3164
jsdService::SetTopLevelHook (jsdICallHook *aHook)
 
3165
{    
 
3166
    mTopLevelHook = aHook;
 
3167
 
 
3168
    /* if the debugger isn't initialized, that's all we can do for now.  The
 
3169
     * OnForRuntime() method will do the rest when the coast is clear.
 
3170
     */
 
3171
    if (!mCx || mPauseLevel)
 
3172
        return NS_OK;
 
3173
 
 
3174
    if (aHook)
 
3175
        JSD_SetTopLevelHook (mCx, jsds_CallHookProc, NULL);
 
3176
    else
 
3177
        JSD_ClearTopLevelHook (mCx);
 
3178
    
 
3179
    return NS_OK;
 
3180
}
 
3181
 
 
3182
NS_IMETHODIMP
 
3183
jsdService::GetTopLevelHook (jsdICallHook **aHook)
 
3184
{   
 
3185
    *aHook = mTopLevelHook;
 
3186
    NS_IF_ADDREF(*aHook);
 
3187
    
 
3188
    return NS_OK;
 
3189
}
 
3190
 
 
3191
NS_IMETHODIMP
 
3192
jsdService::SetFunctionHook (jsdICallHook *aHook)
 
3193
{    
 
3194
    mFunctionHook = aHook;
 
3195
 
 
3196
    /* if the debugger isn't initialized, that's all we can do for now.  The
 
3197
     * OnForRuntime() method will do the rest when the coast is clear.
 
3198
     */
 
3199
    if (!mCx || mPauseLevel)
 
3200
        return NS_OK;
 
3201
 
 
3202
    if (aHook)
 
3203
        JSD_SetFunctionHook (mCx, jsds_CallHookProc, NULL);
 
3204
    else
 
3205
        JSD_ClearFunctionHook (mCx);
 
3206
    
 
3207
    return NS_OK;
 
3208
}
 
3209
 
 
3210
NS_IMETHODIMP
 
3211
jsdService::GetFunctionHook (jsdICallHook **aHook)
 
3212
{   
 
3213
    *aHook = mFunctionHook;
 
3214
    NS_IF_ADDREF(*aHook);
 
3215
    
 
3216
    return NS_OK;
 
3217
}
 
3218
 
 
3219
/* virtual */
 
3220
jsdService::~jsdService()
 
3221
{
 
3222
    ClearFilters();
 
3223
    Off();
 
3224
    gJsds = nsnull;
 
3225
}
 
3226
 
 
3227
jsdService *
 
3228
jsdService::GetService ()
 
3229
{
 
3230
    if (!gJsds)
 
3231
        gJsds = new jsdService();
 
3232
        
 
3233
    NS_IF_ADDREF(gJsds);
 
3234
    return gJsds;
 
3235
}
 
3236
 
 
3237
NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(jsdService, jsdService::GetService)
 
3238
 
 
3239
/* app-start observer.  turns on the debugger at app-start.  this is inserted
 
3240
 * and/or removed from the app-start category by the jsdService::initAtStartup
 
3241
 * property.
 
3242
 */
 
3243
class jsdASObserver : public nsIObserver 
 
3244
{
 
3245
  public:
 
3246
    NS_DECL_ISUPPORTS
 
3247
    NS_DECL_NSIOBSERVER
 
3248
 
 
3249
    jsdASObserver () {}    
 
3250
};
 
3251
 
 
3252
NS_IMPL_THREADSAFE_ISUPPORTS1(jsdASObserver, nsIObserver)
 
3253
 
 
3254
NS_IMETHODIMP
 
3255
jsdASObserver::Observe (nsISupports *aSubject, const char *aTopic,
 
3256
                        const PRUnichar *aData)
 
3257
{
 
3258
    nsresult rv;
 
3259
 
 
3260
    // Hmm.  Why is the app-startup observer called multiple times?
 
3261
    //NS_ASSERTION(!gJsds, "app startup observer called twice");
 
3262
    nsCOMPtr<jsdIDebuggerService> jsds = do_GetService(jsdServiceCtrID, &rv);
 
3263
 
 
3264
    PRBool on;
 
3265
    rv = jsds->GetIsOn(&on);
 
3266
    if (NS_FAILED(rv) || on)
 
3267
        return rv;
 
3268
    
 
3269
    nsCOMPtr<nsIJSRuntimeService> rts = do_GetService(NS_JSRT_CTRID, &rv);
 
3270
    if (NS_FAILED(rv))
 
3271
        return rv;    
 
3272
 
 
3273
    JSRuntime *rt;
 
3274
    rts->GetRuntime (&rt);
 
3275
    if (NS_FAILED(rv))
 
3276
        return rv;
 
3277
 
 
3278
    rv = jsds->OnForRuntime(rt);
 
3279
    if (NS_FAILED(rv))
 
3280
        return rv;
 
3281
    
 
3282
    return jsds->SetFlags(JSD_DISABLE_OBJECT_TRACE);
 
3283
}
 
3284
 
 
3285
NS_GENERIC_FACTORY_CONSTRUCTOR(jsdASObserver)
 
3286
 
 
3287
static const nsModuleComponentInfo components[] = {
 
3288
    {"JSDService", JSDSERVICE_CID,    jsdServiceCtrID, jsdServiceConstructor},
 
3289
    {"JSDASObserver",  JSDASO_CID, jsdASObserverCtrID, jsdASObserverConstructor}
 
3290
};
 
3291
 
 
3292
NS_IMPL_NSGETMODULE(JavaScript_Debugger, components)
 
3293
 
 
3294
/********************************************************************************
 
3295
 ********************************************************************************
 
3296
 * graveyard
 
3297
 */
 
3298
 
 
3299
#if 0
 
3300
/* Thread States */
 
3301
NS_IMPL_THREADSAFE_ISUPPORTS1(jsdThreadState, jsdIThreadState); 
 
3302
 
 
3303
NS_IMETHODIMP
 
3304
jsdThreadState::GetJSDContext(JSDContext **_rval)
 
3305
{
 
3306
    *_rval = mCx;
 
3307
    return NS_OK;
 
3308
}
 
3309
 
 
3310
NS_IMETHODIMP
 
3311
jsdThreadState::GetJSDThreadState(JSDThreadState **_rval)
 
3312
{
 
3313
    *_rval = mThreadState;
 
3314
    return NS_OK;
 
3315
}
 
3316
 
 
3317
NS_IMETHODIMP
 
3318
jsdThreadState::GetFrameCount (PRUint32 *_rval)
 
3319
{
 
3320
    *_rval = JSD_GetCountOfStackFrames (mCx, mThreadState);
 
3321
    return NS_OK;
 
3322
}
 
3323
 
 
3324
NS_IMETHODIMP
 
3325
jsdThreadState::GetTopFrame (jsdIStackFrame **_rval)
 
3326
{
 
3327
    JSDStackFrameInfo *sfi = JSD_GetStackFrame (mCx, mThreadState);
 
3328
    
 
3329
    *_rval = jsdStackFrame::FromPtr (mCx, mThreadState, sfi);
 
3330
    return NS_OK;
 
3331
}
 
3332
 
 
3333
NS_IMETHODIMP
 
3334
jsdThreadState::GetPendingException(jsdIValue **_rval)
 
3335
{
 
3336
    JSDValue *jsdv = JSD_GetException (mCx, mThreadState);
 
3337
    
 
3338
    *_rval = jsdValue::FromPtr (mCx, jsdv);
 
3339
    return NS_OK;
 
3340
}
 
3341
 
 
3342
NS_IMETHODIMP
 
3343
jsdThreadState::SetPendingException(jsdIValue *aException)
 
3344
{
 
3345
    JSDValue *jsdv;
 
3346
    
 
3347
    nsresult rv = aException->GetJSDValue (&jsdv);
 
3348
    if (NS_FAILED(rv))
 
3349
        return NS_ERROR_FAILURE;
 
3350
    
 
3351
    if (!JSD_SetException (mCx, mThreadState, jsdv))
 
3352
        return NS_ERROR_FAILURE;
 
3353
 
 
3354
    return NS_OK;
 
3355
}
 
3356
 
 
3357
#endif