---

TclXPCOMStub.cpp

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * 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 TclXPCOM.
 * 
 * The Initial Developer of the Original Code is Mark Follett.
 * Portions created by Mark Follett are Copyright (C) 2001-2002
 * Mark Follett.  All Rights Reserved.
 * 
 * Contributor(s):
 *     Mark Follett <mef123@myrealbox.com> (Original Author)
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either 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.
 */

#include "TclXPCOMPrivate.h"


nsIID nsisupportsweakreference_iid = NS_ISUPPORTSWEAKREFERENCE_IID;

TclXPCOMStub::TclXPCOMStub(
    nsIInterfaceInfo *interfaceinfo 
)
{
    PRUint16 methodcount;
    
    NS_PRECONDITION(interfaceinfo, "null pointer");

    info = interfaceinfo;
    NS_ADDREF(info);
    
    info->GetMethodCount(&methodcount);

    if (methodcount)
    {
        bindings = (Tcl_Obj **)memmgr->Alloc(sizeof(Tcl_Obj *) * methodcount);
        memset(bindings, 0, sizeof(Tcl_Obj *) * methodcount);
    } else
    {
        bindings = NULL;
    }
}


TclXPCOMStub::~TclXPCOMStub(void)
{
    PRUint16 methodcount, i;
    
    info->GetMethodCount(&methodcount);
    
    for (i = 0; i < methodcount; i++)
    {
        UnsetBinding(i);
    }
    
    if (bindings)
    {
        memmgr->Free(bindings);
    }
    
    NS_RELEASE(info);
}


void
TclXPCOMStub::SetBinding(
    PRUint16 methodindex, 
    Tcl_Obj *script       
)
{
    NS_PRECONDITION(script, "null pointer");

    if (bindings[methodindex])
    {
        UnsetBinding(methodindex);
    }
    
    bindings[methodindex] = script;
    Tcl_IncrRefCount(script);
}


void
TclXPCOMStub::UnsetBinding(
    PRUint16 methodindex 
)
{
    if (bindings[methodindex])
    {
        Tcl_DecrRefCount(bindings[methodindex]);
        bindings[methodindex] = NULL;
    }
}


Tcl_Obj *
TclXPCOMStub::GetBinding(
    PRUint16 methodindex 
)
{
    return bindings[methodindex];
}


NS_IMETHODIMP
TclXPCOMStub::GetInterfaceInfo(
    nsIInterfaceInfo **interfaceinfo 
)
{
    NS_PRECONDITION(interfaceinfo, "null pointer");

    NS_ADDREF(info);
    *interfaceinfo = info;
    return NS_OK;
}


NS_IMETHODIMP
TclXPCOMStub::CallMethod(
    PRUint16               methodIndex,
    const nsXPTMethodInfo *info,       
    nsXPTCMiniVariant     *params      
)
{
    // no precondition on methodIndex
    NS_PRECONDITION(info, "null pointer");
    NS_PRECONDITION(params, "null pointer");

    if (!component->interp)
    {
        // if the interpreter that runs this component is killed,
        // any method invocations will just return an error
        printf("Stub invocation failed cuz the interp is dead!\n");
        return NS_ERROR_FAILURE;
    }

    if (bindings[methodIndex])
    {
        // XXX TODO: make this threadsafe
        NS_ASSERTION((component->thread == Tcl_GetCurrentThread()), "attempt to invoke a component from the wrong thread");
        //--- thread check,  if on different thread,  post an event & wait for return
        return TclXPCOM_CallMethod(component->interp, params, (nsISupports *)(nsXPTCStubBase *)this, this->info, methodIndex, bindings[methodIndex]);
    } else
    {
        return NS_ERROR_NOT_IMPLEMENTED;
    }
}


NS_IMETHODIMP
TclXPCOMStub::QueryInterface(
    REFNSIID   aIID,        
    void     **aInstancePtr 
)
{
    int i;
    nsresult res;
    nsISupports *isupports;
    nsXPTCMiniVariant params[2];

    // no precondition on aIID
    // aInstancePtr checked later

    if (!aInstancePtr)
    {
        return NS_ERROR_NULL_POINTER;
    }

    if (bindings[0] && component->interp && !component->nesting)
    {
        params[0].val.p = (void *)&aIID;
        params[1].val.p = aInstancePtr;

        // XXX TODO: make this threadsafe
        NS_ASSERTION((component->thread == Tcl_GetCurrentThread()), "attempt to invoke a component from the wrong thread");
        //--- thread check,  if on different thread,  post an event & wait for return
        component->nesting = 1;
        res = TclXPCOM_CallMethod(component->interp, params, (nsISupports *)(nsXPTCStubBase *)this, this->info, 0, bindings[0]);
        component->nesting = 0;
        return res;
    }

    for (i = 0; i < component->cinfo->signature.infocount; i++)
    {
        if (isInInterface(component->stubs[i]->info, (nsIID *)&aIID))
        {
            isupports = (nsISupports *)(nsXPTCStubBase *)component->stubs[i];
            NS_ADDREF(isupports);
            *aInstancePtr = isupports;
            return NS_OK;
        }
    }

    // nsISupportsWeakReference is supported by default
    if (aIID.Equals(nsisupportsweakreference_iid))
    {
        isupports = NS_STATIC_CAST(nsISupportsWeakReference*, this);
        NS_ADDREF(isupports);
        *aInstancePtr = isupports;
        return NS_OK;
    }

    *aInstancePtr = NULL;
    return NS_ERROR_NO_INTERFACE;
}


NS_IMETHODIMP_(nsrefcnt)
TclXPCOMStub::AddRef(void)
{
    nsrefcnt count;

    NS_PRECONDITION(PRInt32(component->refcount) >= 0, "illegal refcnt");
    
    count = PR_AtomicIncrement((PRInt32*)&component->refcount);
    NS_LOG_ADDREF(this, count, "TclXPCOMStub", sizeof(*this));

    char str[128];
    sprintf(str, "Addrefing Component %p, Refcount: %d", component, count);
    NS_WARNING(str);

    return count;
}


NS_IMETHODIMP_(nsrefcnt)
TclXPCOMStub::Release(void)
{
    int rv;
    nsrefcnt count;
    Tcl_SavedResult savedresult;

    NS_PRECONDITION(0 != component->refcount, "dup release");
 
    count = PR_AtomicDecrement((PRInt32 *)&component->refcount);
    NS_LOG_RELEASE(this, count, "TclXPCOMStub");

    char str[128];
    sprintf(str, "Releasing Component %p, Refcount: %d", component, count);
    NS_WARNING(str);

    if (0 == count) {
        component->refcount = 1; /* stabilize */
        /* enable this to find non-threadsafe destructors: */
        /* NS_ASSERT_OWNINGTHREAD(_class); */
        
        // tcl destructor script should be called in the release function
        // a destructor script may save [xpcom this] and thus prevent the
        // component from being deleted
        if (component->destructor && component->interp)
        {
            // XXX warn if component->interp == NULL
            // XXX TODO: make this threadsafe
            NS_ASSERTION((component->thread == Tcl_GetCurrentThread()), "attempt to invoke a component from the wrong thread");
            Tcl_Preserve(component->interp);
            Tcl_SaveResult(component->interp, &savedresult);
            rv = Tcl_EvalObjEx(component->interp, component->destructor, TCL_EVAL_GLOBAL);
            if (rv != TCL_OK)
            {
                Tcl_AddObjErrorInfo(component->interp, "\nwhile executing component destructor:\n\"", -1);
                Tcl_AddObjErrorInfo(component->interp, Tcl_GetString(component->destructor), -1);
                Tcl_AddObjErrorInfo(component->interp, "\"", -1);
                TclXPCOM_BackgroundError(component->interp);
            }
            
            Tcl_RestoreResult(component->interp, &savedresult);
            Tcl_Release(component->interp);
        }
        
        if (component->refcount == 1)
        {
            sprintf(str, "Destroyed Component %p", component);
            NS_WARNING(str);

            FreeTclXPCOMComponent(component);

            return 0;
        } else
        {
            component->refcount--;
            return component->refcount;
        }
    }
    return count;
}

---