johnson 1.2.0 → 2.0.0.pre0

data/vendor/tracemonkey/xpconnect/src/xpcexception.cpp

@@ -0,0 +1,502 @@
+/* -*- 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.
+ *
+ * Contributor(s):
+ *   John Bandhauer <jband@netscape.com> (original author)
+ *   Mark Hammond <MarkH@ActiveState.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 ***** */
+
+/* An implementaion of nsIException. */
+
+#include "xpcprivate.h"
+#include "nsNetError.h"
+
+/***************************************************************************/
+/* Quick and dirty mapping of well known result codes to strings. We only
+*  call this when building an exception object, so iterating the short array
+*  is not too bad.
+*
+*  It sure would be nice to have exceptions declared in idl and available
+*  in some more global way at runtime.
+*/
+
+static struct ResultMap
+{nsresult rv; const char* name; const char* format;} map[] = {
+#define XPC_MSG_DEF(val, format) \
+    {(val), #val, format},
+#include "xpc.msg"
+#undef XPC_MSG_DEF
+    {0,0,0}   // sentinel to mark end of array
+};
+
+#define RESULT_COUNT ((sizeof(map) / sizeof(map[0]))-1)
+
+// static
+JSBool
+nsXPCException::NameAndFormatForNSResult(nsresult rv,
+                                         const char** name,
+                                         const char** format)
+{
+
+    for(ResultMap* p = map; p->name; p++)
+    {
+        if(rv == p->rv)
+        {
+            if(name) *name = p->name;
+            if(format) *format = p->format;
+            return JS_TRUE;
+        }
+    }
+    return JS_FALSE;
+}
+
+// static
+void*
+nsXPCException::IterateNSResults(nsresult* rv,
+                                 const char** name,
+                                 const char** format,
+                                 void** iterp)
+{
+    ResultMap* p = (ResultMap*) *iterp;
+    if(!p)
+        p = map;
+    else
+        p++;
+    if(!p->name)
+        p = nsnull;
+    else
+    {
+        if(rv)
+            *rv = p->rv;
+        if(name)
+            *name = p->name;
+        if(format)
+            *format = p->format;
+    }
+    *iterp = p;
+    return p;
+}
+
+// static
+PRUint32
+nsXPCException::GetNSResultCount()
+{
+    return RESULT_COUNT;
+}
+
+/***************************************************************************/
+
+NS_INTERFACE_MAP_BEGIN(nsXPCException)
+  NS_INTERFACE_MAP_ENTRY(nsIException)
+  NS_INTERFACE_MAP_ENTRY(nsIXPCException)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIException)
+  NS_IMPL_QUERY_CLASSINFO(nsXPCException)
+NS_INTERFACE_MAP_END_THREADSAFE
+
+NS_IMPL_THREADSAFE_ADDREF(nsXPCException)
+NS_IMPL_THREADSAFE_RELEASE(nsXPCException)
+
+NS_IMPL_CI_INTERFACE_GETTER1(nsXPCException, nsIXPCException)
+
+nsXPCException::nsXPCException()
+    : mMessage(nsnull),
+      mResult(0),
+      mName(nsnull),
+      mLocation(nsnull),
+      mData(nsnull),
+      mFilename(nsnull),
+      mLineNumber(0),
+      mInner(nsnull),
+      mInitialized(PR_FALSE)
+{
+    MOZ_COUNT_CTOR(nsXPCException);
+}
+
+nsXPCException::~nsXPCException()
+{
+    MOZ_COUNT_DTOR(nsXPCException);
+    Reset();
+}
+
+PRBool
+nsXPCException::StealThrownJSVal(jsval *vp)
+{
+    if(mThrownJSVal.IsHeld())
+    {
+        *vp = mThrownJSVal.Release();
+        return PR_TRUE;
+    }
+    return PR_FALSE;
+}
+
+void
+nsXPCException::StowThrownJSVal(JSContext *cx, jsval v)
+{
+    if (mThrownJSVal.Hold(cx))
+        mThrownJSVal = v;
+}
+
+void
+nsXPCException::Reset()
+{
+    if(mMessage)
+    {
+        nsMemory::Free(mMessage);
+        mMessage = nsnull;
+    }
+    if(mName)
+    {
+        nsMemory::Free(mName);
+        mName = nsnull;
+    }
+    if(mFilename)
+    {
+        nsMemory::Free(mFilename);
+        mFilename = nsnull;
+    }
+    mLineNumber = (PRUint32)-1;
+    NS_IF_RELEASE(mLocation);
+    NS_IF_RELEASE(mData);
+    NS_IF_RELEASE(mInner);
+}
+
+/* readonly attribute string message; */
+NS_IMETHODIMP
+nsXPCException::GetMessageMoz(char * *aMessage)
+{
+    if(!mInitialized)
+        return NS_ERROR_NOT_INITIALIZED;
+    XPC_STRING_GETTER_BODY(aMessage, mMessage);
+}
+
+/* readonly attribute nsresult result; */
+NS_IMETHODIMP
+nsXPCException::GetResult(nsresult *aResult)
+{
+    if(!aResult)
+        return NS_ERROR_NULL_POINTER;
+    if(!mInitialized)
+        return NS_ERROR_NOT_INITIALIZED;
+    *aResult = mResult;
+    return NS_OK;
+}
+
+/* readonly attribute string name; */
+NS_IMETHODIMP
+nsXPCException::GetName(char * *aName)
+{
+    if(!mInitialized)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    const char* name = mName;
+    if(!name)
+        NameAndFormatForNSResult(mResult, &name, nsnull);
+
+    XPC_STRING_GETTER_BODY(aName, name);
+}
+
+/* readonly attribute string filename; */
+NS_IMETHODIMP nsXPCException::GetFilename(char * *aFilename)
+{
+    if(!mInitialized)
+        return NS_ERROR_NOT_INITIALIZED;
+    XPC_STRING_GETTER_BODY(aFilename, mFilename);
+}
+
+/* readonly attribute PRUint32 lineNumber; */
+NS_IMETHODIMP nsXPCException::GetLineNumber(PRUint32 *aLineNumber)
+{
+    if(!aLineNumber)
+        return NS_ERROR_NULL_POINTER;
+    if(!mInitialized)
+        return NS_ERROR_NOT_INITIALIZED;
+    *aLineNumber = mLineNumber;
+    return NS_OK;
+}
+
+/* readonly attribute PRUint32 columnNumber; */
+NS_IMETHODIMP nsXPCException::GetColumnNumber(PRUint32 *aColumnNumber)
+{
+    NS_ENSURE_ARG_POINTER(aColumnNumber);
+    if(!mInitialized)
+        return NS_ERROR_NOT_INITIALIZED;
+    *aColumnNumber = 0;
+    return NS_OK;
+}
+
+/* readonly attribute nsIStackFrame location; */
+NS_IMETHODIMP
+nsXPCException::GetLocation(nsIStackFrame * *aLocation)
+{
+    if(!aLocation)
+        return NS_ERROR_NULL_POINTER;
+    if(!mInitialized)
+        return NS_ERROR_NOT_INITIALIZED;
+    *aLocation = mLocation;
+    NS_IF_ADDREF(mLocation);
+    return NS_OK;
+}
+
+/* readonly attribute nsISupports data; */
+NS_IMETHODIMP
+nsXPCException::GetData(nsISupports * *aData)
+{
+    if(!aData)
+        return NS_ERROR_NULL_POINTER;
+    if(!mInitialized)
+        return NS_ERROR_NOT_INITIALIZED;
+    *aData = mData;
+    NS_IF_ADDREF(mData);
+    return NS_OK;
+}
+
+/* readonly attribute nsIException inner; */
+NS_IMETHODIMP
+nsXPCException::GetInner(nsIException* *aException)
+{
+    if(!aException)
+        return NS_ERROR_NULL_POINTER;
+    if(!mInitialized)
+        return NS_ERROR_NOT_INITIALIZED;
+    *aException = mInner;
+    NS_IF_ADDREF(mInner);
+    return NS_OK;
+}
+
+/* void initialize (in string aMessage, in nsresult aResult, in string aName, in nsIStackFrame aLocation, in nsISupports aData, in nsIException aInner); */
+NS_IMETHODIMP
+nsXPCException::Initialize(const char *aMessage, nsresult aResult, const char *aName, nsIStackFrame *aLocation, nsISupports *aData, nsIException *aInner)
+{
+    if(mInitialized)
+        return NS_ERROR_ALREADY_INITIALIZED;
+
+    Reset();
+
+    if(aMessage)
+    {
+        if(!(mMessage = (char*) nsMemory::Clone(aMessage,
+                                           sizeof(char)*(strlen(aMessage)+1))))
+            return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    if(aName)
+    {
+        if(!(mName = (char*) nsMemory::Clone(aName,
+                                           sizeof(char)*(strlen(aName)+1))))
+            return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    mResult = aResult;
+
+    if(aLocation)
+    {
+        mLocation = aLocation;
+        NS_ADDREF(mLocation);
+        // For now, fill in our location details from our stack frame.
+        // Later we may allow other locations?
+        nsresult rc;
+        if(NS_FAILED(rc = aLocation->GetFilename(&mFilename)))
+            return rc;
+        if(NS_FAILED(rc = aLocation->GetLineNumber(&mLineNumber)))
+            return rc;
+    }
+    else
+    {
+        nsresult rv;
+        nsXPConnect* xpc = nsXPConnect::GetXPConnect();
+        if(!xpc)
+            return NS_ERROR_FAILURE;
+        rv = xpc->GetCurrentJSStack(&mLocation);
+        if(NS_FAILED(rv))
+            return rv;
+    }
+
+    if(aData)
+    {
+        mData = aData;
+        NS_ADDREF(mData);
+    }
+    if(aInner)
+    {
+        mInner = aInner;
+        NS_ADDREF(mInner);
+    }
+
+    mInitialized = PR_TRUE;
+    return NS_OK;
+}
+
+/* string toString (); */
+NS_IMETHODIMP
+nsXPCException::ToString(char **_retval)
+{
+    if(!_retval)
+        return NS_ERROR_NULL_POINTER;
+    if(!mInitialized)
+        return NS_ERROR_NOT_INITIALIZED;
+
+    static const char defaultMsg[] = "<no message>";
+    static const char defaultLocation[] = "<unknown>";
+    static const char format[] =
+ "[Exception... \"%s\"  nsresult: \"0x%x (%s)\"  location: \"%s\"  data: %s]";
+
+    char* indicatedLocation = nsnull;
+
+    if(mLocation)
+    {
+        // we need to free this if it does not fail
+        nsresult rv = mLocation->ToString(&indicatedLocation);
+        if(NS_FAILED(rv))
+            return rv;
+    }
+
+    const char* msg = mMessage ? mMessage : nsnull;
+    const char* location = indicatedLocation ?
+                                indicatedLocation : defaultLocation;
+    const char* resultName = mName;
+    if(!resultName && !NameAndFormatForNSResult(mResult, &resultName,
+                                                (!msg) ? &msg : nsnull))
+    {
+        if(!msg)
+            msg = defaultMsg;
+        resultName = "<unknown>";
+    }
+    const char* data = mData ? "yes" : "no";
+
+    char* temp = JS_smprintf(format, msg, mResult, resultName, location, data);
+    if(indicatedLocation)
+        nsMemory::Free(indicatedLocation);
+
+    char* final = nsnull;
+    if(temp)
+    {
+        final = (char*) nsMemory::Clone(temp, sizeof(char)*(strlen(temp)+1));
+        JS_smprintf_free(temp);
+    }
+
+    *_retval = final;
+    return final ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+}
+
+JSBool nsXPCException::sEverMadeOneFromFactory = JS_FALSE;
+
+// static
+nsresult
+nsXPCException::NewException(const char *aMessage,
+                             nsresult aResult,
+                             nsIStackFrame *aLocation,
+                             nsISupports *aData,
+                             nsIException** exceptn)
+{
+    // A little hack... The nsIGenericModule nsIClassInfo scheme relies on there
+    // having been at least one instance made via the factory. Otherwise, the
+    // shared factory/classinsance object never gets created and our QI getter
+    // for our instance's pointer to our nsIClassInfo will always return null.
+    // This is bad because it means that wrapped exceptions will never have a
+    // shared prototype. So... We force one to be created via the factory
+    // *once* and then go about our business.
+    if(!sEverMadeOneFromFactory)
+    {
+        nsCOMPtr<nsIXPCException> e =
+            do_CreateInstance(XPC_EXCEPTION_CONTRACTID);
+        sEverMadeOneFromFactory = JS_TRUE;
+    }
+
+    nsresult rv;
+    nsXPCException* e = new nsXPCException();
+    if(e)
+    {
+        NS_ADDREF(e);
+
+        nsIStackFrame* location;
+        if(aLocation)
+        {
+            location = aLocation;
+            NS_ADDREF(location);
+        }
+        else
+        {
+            nsXPConnect* xpc = nsXPConnect::GetXPConnect();
+            if(!xpc)
+            {
+                NS_RELEASE(e);
+                return NS_ERROR_FAILURE;
+            }
+            rv = xpc->GetCurrentJSStack(&location);
+            if(NS_FAILED(rv))
+            {
+                NS_RELEASE(e);
+                return NS_ERROR_FAILURE;
+            }
+            // it is legal for there to be no active JS stack, if C++ code
+            // is operating on a JS-implemented interface pointer without
+            // having been called in turn by JS.  This happens in the JS
+            // component loader, and will become more common as additional
+            // components are implemented in JS.
+        }
+        // We want to trim off any leading native 'dataless' frames
+        if(location)
+            while(1)
+            {
+                PRUint32 language;
+                PRInt32 lineNumber;
+                if(NS_FAILED(location->GetLanguage(&language)) ||
+                   language == nsIProgrammingLanguage::JAVASCRIPT ||
+                   NS_FAILED(location->GetLineNumber(&lineNumber)) ||
+                   lineNumber)
+                {
+                    break;
+                }
+                nsCOMPtr<nsIStackFrame> caller;
+                if(NS_FAILED(location->GetCaller(getter_AddRefs(caller))) || !caller)
+                    break;
+                NS_RELEASE(location);
+                caller->QueryInterface(NS_GET_IID(nsIStackFrame), (void **)&location);
+            }
+        // at this point we have non-null location with one extra addref,
+        // or no location at all
+        rv = e->Initialize(aMessage, aResult, nsnull, location, aData, nsnull);
+        NS_IF_RELEASE(location);
+        if(NS_FAILED(rv))
+            NS_RELEASE(e);
+    }
+
+    if(!e)
+        return NS_ERROR_FAILURE;
+
+    *exceptn = static_cast<nsIXPCException*>(e);
+    return NS_OK;
+}