johnson 1.2.0 → 2.0.0.pre0

data/vendor/tracemonkey/xpconnect/loader/mozJSComponentLoader.h

@@ -0,0 +1,172 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributors:
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#include "plhash.h"
+#include "jsapi.h"
+#include "nsIModuleLoader.h"
+#include "nsIJSRuntimeService.h"
+#include "nsIJSContextStack.h"
+#include "nsISupports.h"
+#include "nsIXPConnect.h"
+#include "nsIModule.h"
+#include "nsIFile.h"
+#include "nsAutoPtr.h"
+#include "nsIFastLoadService.h"
+#include "nsIObjectInputStream.h"
+#include "nsIObjectOutputStream.h"
+#include "nsITimer.h"
+#include "nsIObserver.h"
+#include "xpcIJSModuleLoader.h"
+#include "nsClassHashtable.h"
+#include "nsDataHashtable.h"
+#ifndef XPCONNECT_STANDALONE
+#include "nsIPrincipal.h"
+#endif
+
+/* 6bd13476-1dd2-11b2-bbef-f0ccb5fa64b6 (thanks, mozbot) */
+
+#define MOZJSCOMPONENTLOADER_CID \
+  {0x6bd13476, 0x1dd2, 0x11b2, \
+    { 0xbb, 0xef, 0xf0, 0xcc, 0xb5, 0xfa, 0x64, 0xb6 }}
+#define MOZJSCOMPONENTLOADER_CONTRACTID "@mozilla.org/moz/jsloader;1"
+#define MOZJSCOMPONENTLOADER_TYPE_NAME "text/javascript"
+
+// nsIFastLoadFileIO implementation for component fastload
+class nsXPCFastLoadIO : public nsIFastLoadFileIO
+{
+ public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIFASTLOADFILEIO
+
+    nsXPCFastLoadIO(nsIFile *file) : mFile(file) {}
+
+    void SetInputStream(nsIInputStream *stream) { mInputStream = stream; }
+    void SetOutputStream(nsIOutputStream *stream) { mOutputStream = stream; }
+
+ private:
+    ~nsXPCFastLoadIO() {}
+
+    nsCOMPtr<nsIFile> mFile;
+    nsCOMPtr<nsIInputStream> mInputStream;
+    nsCOMPtr<nsIOutputStream> mOutputStream;
+};
+
+
+class mozJSComponentLoader : public nsIModuleLoader,
+                             public xpcIJSModuleLoader,
+                             public nsIObserver
+{
+    friend class JSCLContextHelper;
+ public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIMODULELOADER
+    NS_DECL_XPCIJSMODULELOADER
+    NS_DECL_NSIOBSERVER
+
+    mozJSComponentLoader();
+    virtual ~mozJSComponentLoader();
+
+ protected:
+    static mozJSComponentLoader* sSelf;
+
+    nsresult ReallyInit();
+    void UnloadModules();
+
+    nsresult GlobalForLocation(nsILocalFile *aComponent,
+                               JSObject **aGlobal,
+                               char **location,
+                               jsval *exception);
+
+    nsresult StartFastLoad(nsIFastLoadService *flSvc);
+    nsresult ReadScript(nsIFastLoadService *flSvc, const char *nativePath,
+                        nsIURI *uri, JSContext *cx, JSScript **script);
+    nsresult WriteScript(nsIFastLoadService *flSvc, JSScript *script,
+                         nsIFile *component, const char *nativePath,
+                         nsIURI *uri, JSContext *cx);
+    static void CloseFastLoad(nsITimer *timer, void *closure);
+    void CloseFastLoad();
+
+    nsCOMPtr<nsIComponentManager> mCompMgr;
+    nsCOMPtr<nsIJSRuntimeService> mRuntimeService;
+    nsCOMPtr<nsIThreadJSContextStack> mContextStack;
+    nsCOMPtr<nsIFile> mFastLoadFile;
+    nsRefPtr<nsXPCFastLoadIO> mFastLoadIO;
+    nsCOMPtr<nsIObjectInputStream> mFastLoadInput;
+    nsCOMPtr<nsIObjectOutputStream> mFastLoadOutput;
+    nsCOMPtr<nsITimer> mFastLoadTimer;
+#ifndef XPCONNECT_STANDALONE
+    nsCOMPtr<nsIPrincipal> mSystemPrincipal;
+#endif
+    JSRuntime *mRuntime;
+    JSContext *mContext;
+
+    class ModuleEntry
+    {
+    public:
+        ModuleEntry() {
+            global = nsnull;
+            location = nsnull;
+        }
+
+        ~ModuleEntry() {
+            module = nsnull;
+
+            if (global) {
+                JSAutoRequest ar(sSelf->mContext);
+                JS_ClearScope(sSelf->mContext, global);
+                JS_RemoveRoot(sSelf->mContext, &global);
+            }
+
+            if (location)
+                NS_Free(location);
+        }
+
+        nsCOMPtr<nsIModule>  module;
+        JSObject            *global;
+        char                *location;
+    };
+
+    friend class ModuleEntry;
+
+    nsClassHashtable<nsHashableHashKey, ModuleEntry> mModules;
+    nsClassHashtable<nsHashableHashKey, ModuleEntry> mImports;
+    nsDataHashtable<nsHashableHashKey, ModuleEntry*> mInProgressImports;
+
+    PRBool mInitialized;
+};

data/vendor/tracemonkey/xpconnect/loader/mozJSLoaderConstructors.h

@@ -0,0 +1,101 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1999
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributors:
+ *   Mike Shaver <shaver@zeroknowledge.com>
+ *   John Bandhauer <jband@netscape.com>
+ *   IBM Corp.
+ *   Robert Ginda <rginda@netscape.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#ifdef XPCONNECT_STANDALONE
+#define NO_SUBSCRIPT_LOADER
+#endif
+
+#include "nsIGenericFactory.h"
+#include "nsICategoryManager.h"
+#include "mozJSComponentLoader.h"
+
+#ifndef NO_SUBSCRIPT_LOADER
+#include "mozJSSubScriptLoader.h"
+const char mozJSSubScriptLoadContractID[] = "@mozilla.org/moz/jssubscript-loader;1";
+#endif
+
+static NS_METHOD
+RegisterJSLoader(nsIComponentManager *aCompMgr, nsIFile *aPath,
+                 const char *registryLocation, const char *componentType,
+                 const nsModuleComponentInfo *info)
+{
+    nsresult rv;
+    nsCOMPtr<nsICategoryManager> catman =
+        do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
+    if (NS_FAILED(rv)) return rv;
+    nsXPIDLCString previous;
+    return catman->AddCategoryEntry("module-loader",
+                                    MOZJSCOMPONENTLOADER_TYPE_NAME,
+                                    MOZJSCOMPONENTLOADER_CONTRACTID,
+                                    PR_TRUE, PR_TRUE, getter_Copies(previous));
+}
+
+static NS_METHOD
+UnregisterJSLoader(nsIComponentManager *aCompMgr, nsIFile *aPath,
+                   const char *registryLocation,
+                   const nsModuleComponentInfo *info)
+{
+    nsresult rv;
+    nsCOMPtr<nsICategoryManager> catman =
+        do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
+    if (NS_FAILED(rv)) return rv;
+    nsXPIDLCString jsLoader;
+    rv = catman->GetCategoryEntry("module-loader",
+                                  MOZJSCOMPONENTLOADER_TYPE_NAME,
+                                  getter_Copies(jsLoader));
+    if (NS_FAILED(rv)) return rv;
+
+    // only unregister if we're the current JS component loader
+    if (!strcmp(jsLoader, MOZJSCOMPONENTLOADER_CONTRACTID)) {
+        return catman->DeleteCategoryEntry("module-loader",
+                                           MOZJSCOMPONENTLOADER_TYPE_NAME,
+                                           PR_TRUE);
+    }
+    return NS_OK;
+}
+
+NS_GENERIC_FACTORY_CONSTRUCTOR(mozJSComponentLoader)
+
+#ifndef NO_SUBSCRIPT_LOADER
+NS_GENERIC_FACTORY_CONSTRUCTOR(mozJSSubScriptLoader)
+#endif

data/vendor/tracemonkey/xpconnect/loader/mozJSSubScriptLoader.cpp

@@ -0,0 +1,360 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=4 sw=4 et tw=80:
+ *
+ * ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1998
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Robert Ginda <rginda@netscape.com>
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#if !defined(XPCONNECT_STANDALONE) && !defined(NO_SUBSCRIPT_LOADER)
+
+#include "mozJSSubScriptLoader.h"
+
+#include "nsIServiceManager.h"
+#include "nsIXPConnect.h"
+
+#include "nsIURI.h"
+#include "nsIIOService.h"
+#include "nsIChannel.h"
+#include "nsIInputStream.h"
+#include "nsNetCID.h"
+#include "nsDependentString.h"
+#include "nsAutoPtr.h"
+#include "nsNetUtil.h"
+#include "nsIProtocolHandler.h"
+#include "nsIFileURL.h"
+
+#include "jsapi.h"
+#include "jsdbgapi.h"
+
+/* load() error msgs, XXX localize? */
+#define LOAD_ERROR_NOSERVICE "Error creating IO Service."
+#define LOAD_ERROR_NOURI "Error creating URI (invalid URL scheme?)"
+#define LOAD_ERROR_NOSCHEME "Failed to get URI scheme.  This is bad."
+#define LOAD_ERROR_URI_NOT_LOCAL "Trying to load a non-local URI."
+#define LOAD_ERROR_NOSTREAM  "Error opening input stream (invalid filename?)"
+#define LOAD_ERROR_NOCONTENT "ContentLength not available (not a local URL?)"
+#define LOAD_ERROR_BADREAD   "File Read Error."
+#define LOAD_ERROR_READUNDERFLOW "File Read Error (underflow.)"
+#define LOAD_ERROR_NOPRINCIPALS "Failed to get principals."
+#define LOAD_ERROR_NOSPEC "Failed to get URI spec.  This is bad."
+
+// We just use the same reporter as the component loader
+extern void
+mozJSLoaderErrorReporter(JSContext *cx, const char *message, JSErrorReport *rep);
+
+mozJSSubScriptLoader::mozJSSubScriptLoader() : mSystemPrincipal(nsnull)
+{
+}
+
+mozJSSubScriptLoader::~mozJSSubScriptLoader()    
+{
+    /* empty */
+}
+
+NS_IMPL_THREADSAFE_ISUPPORTS1(mozJSSubScriptLoader, mozIJSSubScriptLoader)
+
+NS_IMETHODIMP /* args and return value are delt with using XPConnect and JSAPI */
+mozJSSubScriptLoader::LoadSubScript (const PRUnichar * /*url*/
+                                     /* [, JSObject *target_obj] */)
+{
+    /*
+     * Loads a local url and evals it into the current cx
+     * Synchronous (an async version would be cool too.)
+     *   url: The url to load.  Must be local so that it can be loaded
+     *        synchronously.
+     *   target_obj: Optional object to eval the script onto (defaults to context
+     *               global)
+     *   returns: Whatever jsval the script pointed to by the url returns.
+     * Should ONLY (O N L Y !) be called from JavaScript code.
+     */
+    
+    /* gotta define most of this stuff up here because of all the gotos,
+     * defined the rest up here to be consistent */
+    nsresult  rv;
+    JSBool    ok;
+
+    /* get JS things from the CallContext */
+    nsCOMPtr<nsIXPConnect> xpc = do_GetService(nsIXPConnect::GetCID());
+    if (!xpc) return NS_ERROR_FAILURE;
+
+    nsAXPCNativeCallContext *cc = nsnull;
+    rv = xpc->GetCurrentNativeCallContext(&cc);
+    if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
+
+    JSContext *cx;
+    rv = cc->GetJSContext (&cx);
+    if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
+
+    PRUint32 argc;
+    rv = cc->GetArgc (&argc);
+    if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
+
+    jsval *argv;
+    rv = cc->GetArgvPtr (&argv);
+    if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
+
+    jsval *rval;
+    rv = cc->GetRetValPtr (&rval);
+    if (NS_FAILED(rv)) return NS_ERROR_FAILURE;    
+
+    /* set mJSPrincipals if it's not here already */
+    if (!mSystemPrincipal)
+    {
+        nsCOMPtr<nsIScriptSecurityManager> secman =
+            do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID);
+        if (!secman)
+            return rv;
+
+        rv = secman->GetSystemPrincipal(getter_AddRefs(mSystemPrincipal));
+        if (NS_FAILED(rv) || !mSystemPrincipal)
+            return rv;
+    }
+
+    JSAutoRequest ar(cx);
+
+    char     *url;
+    JSObject *target_obj = nsnull;
+    ok = JS_ConvertArguments (cx, argc, argv, "s / o", &url, &target_obj);
+    if (!ok)
+    {
+        /* let the exception raised by JS_ConvertArguments show through */
+        return NS_OK;
+    }
+
+    if (!target_obj)
+    {
+        /* if the user didn't provide an object to eval onto, find the global
+         * object by walking the parent chain of the calling object */
+
+#ifdef DEBUG_rginda
+        JSObject *got_glob = JS_GetGlobalObject (cx);
+        fprintf (stderr, "JS_GetGlobalObject says glob is %p.\n", got_glob);
+        target_obj = JS_GetPrototype (cx, got_glob);
+        fprintf (stderr, "That glob's prototype is %p.\n", target_obj);
+        target_obj = JS_GetParent (cx, got_glob);
+        fprintf (stderr, "That glob's parent is %p.\n", target_obj);
+#endif
+        
+        nsCOMPtr<nsIXPConnectWrappedNative> wn;
+        rv = cc->GetCalleeWrapper (getter_AddRefs(wn));
+        if (NS_FAILED(rv)) return NS_ERROR_FAILURE;    
+
+        rv = wn->GetJSObject (&target_obj);
+        if (NS_FAILED(rv)) return NS_ERROR_FAILURE;
+
+#ifdef DEBUG_rginda
+        fprintf (stderr, "Parent chain: %p", target_obj);
+#endif
+        JSObject *maybe_glob = JS_GetParent (cx, target_obj);
+        while (maybe_glob != nsnull)
+        {
+#ifdef DEBUG_rginda
+            fprintf (stderr, ", %p", maybe_glob);
+#endif
+            target_obj = maybe_glob;
+            maybe_glob = JS_GetParent (cx, maybe_glob);
+        }
+#ifdef DEBUG_rginda
+        fprintf (stderr, "\n");
+#endif  
+    }
+
+    // Innerize the target_obj so that we compile the loaded script in the
+    // correct (inner) scope.
+    JSClass *target_class = JS_GET_CLASS(cx, target_obj);
+    if (target_class->flags & JSCLASS_IS_EXTENDED)
+    {
+        JSExtendedClass *extended = (JSExtendedClass*)target_class;
+        if (extended->innerObject)
+        {
+            target_obj = extended->innerObject(cx, target_obj);
+            if (!target_obj) return NS_ERROR_FAILURE;
+#ifdef DEBUG_rginda
+            fprintf (stderr, "Final global: %p\n", target_obj);
+#endif
+        }
+    }
+
+    /* load up the url.  From here on, failures are reflected as ``custom''
+     * js exceptions */
+    PRInt32   len = -1;
+    PRUint32  readcount = 0;  // Total amount of data read
+    PRUint32  lastReadCount = 0;  // Amount of data read in last Read() call
+    nsAutoArrayPtr<char> buf;
+    
+    JSString        *errmsg;
+    JSErrorReporter  er;
+    JSPrincipals    *jsPrincipals;
+    
+    nsCOMPtr<nsIChannel>     chan;
+    nsCOMPtr<nsIInputStream> instream;
+    nsCOMPtr<nsIURI> uri;
+    nsCAutoString uriStr;
+    nsCAutoString scheme;
+
+    JSStackFrame* frame = nsnull;
+    JSScript* script = nsnull;
+
+    // Figure out who's calling us
+    do
+    {
+        frame = JS_FrameIterator(cx, &frame);
+
+        if (frame)
+            script = JS_GetFrameScript(cx, frame);
+    } while (frame && !script);
+
+    if (!script)
+    {
+        // No script means we don't know who's calling, bail.
+
+        return NS_ERROR_FAILURE;
+    }
+
+    nsCOMPtr<nsIIOService> serv = do_GetService(NS_IOSERVICE_CONTRACTID);
+    if (!serv)
+    {
+        errmsg = JS_NewStringCopyZ (cx, LOAD_ERROR_NOSERVICE);
+        goto return_exception;
+    }
+
+    // Make sure to explicitly create the URI, since we'll need the
+    // canonicalized spec.
+    rv = NS_NewURI(getter_AddRefs(uri), url, nsnull, serv);
+    if (NS_FAILED(rv)) {
+        errmsg = JS_NewStringCopyZ (cx, LOAD_ERROR_NOURI);
+        goto return_exception;
+    }
+
+    rv = uri->GetSpec(uriStr);
+    if (NS_FAILED(rv)) {
+        errmsg = JS_NewStringCopyZ (cx, LOAD_ERROR_NOSPEC);
+        goto return_exception;
+    }    
+
+    rv = uri->GetScheme(scheme);
+    if (NS_FAILED(rv))
+    {
+        errmsg = JS_NewStringCopyZ (cx, LOAD_ERROR_NOSCHEME);
+        goto return_exception;
+    }
+
+    if (!scheme.EqualsLiteral("chrome"))
+    {
+        // This might be a URI to a local file, though!
+        nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(uri);
+        if (!fileURL)
+        {
+            errmsg = JS_NewStringCopyZ (cx, LOAD_ERROR_URI_NOT_LOCAL);
+            goto return_exception;
+        }
+
+        // For file URIs prepend the filename with the filename of the
+        // calling script, and " -> ". See bug 418356.
+        nsCAutoString tmp(JS_GetScriptFilename(cx, script));
+        tmp.AppendLiteral(" -> ");
+        tmp.Append(uriStr);
+
+        uriStr = tmp;
+    }        
+        
+    rv = NS_OpenURI(getter_AddRefs(instream), uri, serv,
+                    nsnull, nsnull, nsIRequest::LOAD_NORMAL,
+                    getter_AddRefs(chan));
+    if (NS_FAILED(rv))
+    {
+        errmsg = JS_NewStringCopyZ (cx, LOAD_ERROR_NOSTREAM);
+        goto return_exception;
+    }
+    
+    rv = chan->GetContentLength (&len);
+    if (NS_FAILED(rv) || len == -1)
+    {
+        errmsg = JS_NewStringCopyZ (cx, LOAD_ERROR_NOCONTENT);
+        goto return_exception;
+    }
+
+    buf = new char[len + 1];
+    if (!buf)
+        return NS_ERROR_OUT_OF_MEMORY;
+    buf[len] = '\0';
+    
+    do {
+        rv = instream->Read (buf + readcount, len - readcount, &lastReadCount);
+        if (NS_FAILED(rv))
+        {
+            errmsg = JS_NewStringCopyZ (cx, LOAD_ERROR_BADREAD);
+            goto return_exception;
+        }
+        readcount += lastReadCount;
+    } while (lastReadCount && readcount != PRUint32(len));
+    
+    if (static_cast<PRUint32>(len) != readcount)
+    {
+        errmsg = JS_NewStringCopyZ (cx, LOAD_ERROR_READUNDERFLOW);
+        goto return_exception;
+    }
+
+    /* we can't hold onto jsPrincipals as a module var because the
+     * JSPRINCIPALS_DROP macro takes a JSContext, which we won't have in the
+     * destructor */
+    rv = mSystemPrincipal->GetJSPrincipals(cx, &jsPrincipals);
+    if (NS_FAILED(rv) || !jsPrincipals) {
+        errmsg = JS_NewStringCopyZ (cx, LOAD_ERROR_NOPRINCIPALS);
+        goto return_exception;
+    }
+
+    /* set our own error reporter so we can report any bad things as catchable
+     * exceptions, including the source/line number */
+    er = JS_SetErrorReporter (cx, mozJSLoaderErrorReporter);
+
+    ok = JS_EvaluateScriptForPrincipals (cx, target_obj, jsPrincipals,
+                                         buf, len, uriStr.get(), 1, rval);        
+    /* repent for our evil deeds */
+    JS_SetErrorReporter (cx, er);
+
+    cc->SetReturnValueWasSet (ok);
+
+    JSPRINCIPALS_DROP(cx, jsPrincipals);
+    return NS_OK;
+
+ return_exception:
+    JS_SetPendingException (cx, STRING_TO_JSVAL(errmsg));
+    return NS_OK;
+}
+
+#endif /* NO_SUBSCRIPT_LOADER */