---

TclXPCOMInterfaceRef.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"


// XXX TODO: make irefhash threadsafe
Tcl_HashTable irefhash;


InterfaceRef *
NewInterfaceRef(void)
{
    InterfaceRef *iref;

    iref = (InterfaceRef *)memmgr->Alloc(sizeof(InterfaceRef));

    Tcl_InitHashTable(&iref->refhash, TCL_ONE_WORD_KEYS);

    iref->refcount    = 0;
    iref->cinforef    = NULL;
    iref->cinfo       = NULL;
    iref->cisupported = 1;

    return iref;
}


Tcl_HashEntry *
AddISupportsToInterfaceRef(
    InterfaceRef     *iref,         
    nsISupports      *isupports,    
    nsIInterfaceInfo *interfaceinfo 
)
{
    int newentry;
    Tcl_HashEntry *entry;

    NS_PRECONDITION(iref, "null pointer");
    NS_PRECONDITION(isupports, "null pointer");
    NS_PRECONDITION(interfaceinfo, "null pointer");

    entry = Tcl_CreateHashEntry(&irefhash, (char *)isupports, &newentry);
    if (newentry)
    {
        Tcl_SetHashValue(entry, iref);
        NS_ADDREF(isupports);
    }

    entry = Tcl_CreateHashEntry(&iref->refhash, (char *)interfaceinfo, &newentry);
    if (newentry)
    {
        Tcl_SetHashValue(entry, isupports);
        NS_ADDREF(interfaceinfo);
    }

    return entry;

//        char str[128];
//        char str1[128];
//        const char *name;
//        interfaceinfo->GetNameShared(&name);
//        sprintf(str, "xpcom::inscope %s::%p", name, isupports);
//        sprintf(str1, "Adding to iref %p: %s", iref, str);
//        NS_WARNING(str1);
//        printf("Adding to iref %p: %s\n", iref, str);

}


void
MergeInterfaceRefs(
    InterfaceRef *irefa, 
    InterfaceRef *irefb  
)
{
    int newentry;
    Tcl_HashEntry  *entrya, *entryb, *refentry;
    Tcl_HashSearch search;
    nsIInterfaceInfo *interfaceinfo;
    nsISupports      *isupports;

    NS_PRECONDITION(irefa, "null pointer");
    NS_PRECONDITION(irefb, "null pointer");

    NS_ASSERTION(!(irefa == irefb), "attempting to merge an InterfaceRef with itself");

    for (entryb = Tcl_FirstHashEntry(&irefb->refhash, &search); entryb; entryb = Tcl_NextHashEntry(&search))
    {
        interfaceinfo = (nsIInterfaceInfo *)Tcl_GetHashKey(&irefb->refhash, entryb);
        isupports     = (nsISupports      *)Tcl_GetHashValue(entryb);

        entrya = Tcl_CreateHashEntry(&irefa->refhash, (char *)interfaceinfo, &newentry);

        NS_ASSERTION(newentry, "interfaceinfo entry must not already exist in this iref");

        Tcl_SetHashValue(entrya, isupports);

        refentry = Tcl_FindHashEntry(&irefhash, (char *)isupports);
        Tcl_SetHashValue(refentry, irefa);
    }

    Tcl_DeleteHashTable(&irefb->refhash);

    irefa->refcount += irefb->refcount;
    irefa->cisupported &= irefb->cisupported;

    if (!irefa->cinforef && irefb->cinforef)
    {
        irefa->cinforef = irefb->cinforef;
    } else if (irefb->cinforef)
    {
        NS_RELEASE(irefb->cinforef);
    }

    if (irefb->cinfo)
    {
        irefa->cinfo = irefb->cinfo;
    }

    memmgr->Free(irefb);
}


void
FreeInterfaceRef(
    InterfaceRef *iref 
)
{
    Tcl_HashEntry    *entry, *deletedentry;
    Tcl_HashSearch    search;
    nsIInterfaceInfo *interfaceinfo;
    nsISupports      *isupports;

    NS_PRECONDITION(iref, "null pointer");

    for (entry = Tcl_FirstHashEntry(&iref->refhash, &search); entry; entry = Tcl_NextHashEntry(&search))
    {
        interfaceinfo = (nsIInterfaceInfo *)Tcl_GetHashKey(&iref->refhash, entry);
        isupports     = (nsISupports      *)Tcl_GetHashValue(entry);

//        char str[128];
//        char str1[128];
//        const char *name;
//        interfaceinfo->GetNameShared(&name);
//        sprintf(str, "xpcom::inscope %s::%p", name, isupports);
//        sprintf(str1, "Removing from iref %p: %s", iref, str);
//        NS_WARNING(str1);

        deletedentry = Tcl_FindHashEntry(&irefhash, (char *)isupports);

        if (deletedentry)
        {
            NS_ASSERTION((Tcl_GetHashValue(deletedentry) == iref), "deleted entry doesn't point to this iref");
            Tcl_DeleteHashEntry(deletedentry);
            NS_RELEASE(isupports);
        }

        NS_RELEASE(interfaceinfo);
    }

    Tcl_DeleteHashTable(&iref->refhash);

    if (iref->cinforef)
    {
        NS_RELEASE(iref->cinforef);
    }

    memmgr->Free(iref);
}


int
AddRefInterface(
    nsISupports      *isupports,    
    nsIInterfaceInfo *interfaceinfo,
    Tcl_HashEntry   **entryout      
)
{
    InterfaceRef *iref;
    Tcl_HashEntry *entry;

    NS_PRECONDITION(isupports, "null pointer");
    NS_PRECONDITION(interfaceinfo, "null pointer");
    // no precondition on entryout

    iref = GetInterfaceRef(isupports);

    if (!iref)
    {
        iref = NewInterfaceRef();
    }

    entry = AddISupportsToInterfaceRef(iref, isupports, interfaceinfo);
    if (entryout)
    {
        *entryout = entry;
    }

    iref->refcount++;
//  printf("(Addrefed)Refcount: %d\n", iref->refcount);
    return iref->refcount;
}


int
ReleaseInterface(
    nsISupports *isupports 
)
{
    InterfaceRef *iref;

    NS_PRECONDITION(isupports, "null pointer");

    iref = GetInterfaceRef(isupports);

    NS_ASSERTION(iref, "attempting to release an unknown isupports");

    iref->refcount--;
//  printf("(Released)Refcount: %d\n", iref->refcount);
    if (iref->refcount <= 0)
    {
        FreeInterfaceRef(iref);
    }
    return iref->refcount;
}


InterfaceRef *
GetInterfaceRef(
    nsISupports *isupports 
)
{
    Tcl_HashEntry *entry;

    NS_PRECONDITION(isupports, "null pointer");

    entry = Tcl_FindHashEntry(&irefhash, (char *)isupports);

    if (entry)
    {
        return (InterfaceRef *)Tcl_GetHashValue(entry);
    } else
    {
        return NULL;
    }
}


int
QueryInterfaceIRef(
    Tcl_Interp        *interp,   
    InterfaceRef      *iref,     
    nsIInterfaceInfo  *queryinfo,
    nsISupports      **result    
)
{
    nsresult res;
    Tcl_HashEntry *entry, *firstentry;
    Tcl_HashSearch search;
    const nsIID *iid;
    nsISupports *isupports, *firstisupports;
    InterfaceRef *irefb;

    // no precondition on interp
    NS_PRECONDITION(iref, "null pointer");
    NS_PRECONDITION(queryinfo, "null pointer");
    NS_PRECONDITION(result, "null pointer");

    entry = Tcl_FindHashEntry(&iref->refhash, (char *)queryinfo);
    if (!entry)
    {
        if ((queryinfo == nsiclassinfo_info) && iref->cinforef)
        {
            *result = iref->cinforef;
            return TCL_OK;
        }

        queryinfo->GetIIDShared(&iid);

        firstentry = Tcl_FirstHashEntry(&iref->refhash, &search);
        firstisupports = (nsISupports *)Tcl_GetHashValue(firstentry);

        res = firstisupports->QueryInterface(*iid, (void **)&isupports);

        if (NS_FAILED(res))
        {
            if (interp)
            {
                TclXPCOM_SetError(interp, res);
            }
            return TCL_ERROR;
        }

        if (queryinfo == nsiclassinfo_info)
        {
            iref->cinforef = (nsIClassInfo *)isupports;
            NS_ADDREF(iref->cinforef);
        } else
        {
            irefb = GetInterfaceRef(isupports);

            if (irefb && (iref != irefb))
            {
                MergeInterfaceRefs(iref, irefb);
            } else
            {
                AddISupportsToInterfaceRef(iref, isupports, queryinfo);
            }
        }

        *result = isupports;
        NS_RELEASE(isupports);

    } else
    {
        *result = (nsISupports *)Tcl_GetHashValue(entry);
    }

    return TCL_OK;
}


ClassInfo *
GetClassInfoFromIRef(
    InterfaceRef *iref 
)
{
    int rv;
    nsresult res;
    nsIClassInfo *cinforef;
    PRUint32 iidcount, i;
    nsIID **iids;

    NS_PRECONDITION(iref, "null pointer");

    if (iref->cinfo)
    {
        return iref->cinfo;
    }

    if (!iref->cisupported)
    {
        return NULL;
    }
    
    rv = QueryInterfaceIRef(NULL, iref, nsiclassinfo_info, (nsISupports **)&cinforef);

    if (rv != TCL_OK)
    {
        iref->cisupported = 0;
        return NULL;
    }

    res = cinforef->GetInterfaces(&iidcount, &iids);

    if (NS_FAILED(res) || iidcount == 0)
    {
        iref->cisupported = 0;
        return NULL;
    }

    iref->cinfo = TclXPCOM_GetClassInfo(iidcount, iids);

    for (i = 0; i < iidcount; i++)
    {
        memmgr->Free(iids[i]);
    }

    memmgr->Free(iids);

    return iref->cinfo;
}


int
GetMethodFromIRef(
    Tcl_Interp        *interp,       
    nsISupports       *isupports,    
    nsIInterfaceInfo  *interfaceinfo,
    Tcl_Obj           *identifier,   
    int                type,         
    nsIInterfaceInfo **infoout,      
    PRUint16          *methodindex   
)
{
    int rv;
    char *name;
    Tcl_Obj *nameobj;
    ClassInfo *cinfo;
    IdentifierInfo *idinfo;

    NS_PRECONDITION(interp, "null pointer");
    NS_PRECONDITION(isupports, "null pointer");
    NS_PRECONDITION(interfaceinfo, "null pointer");
    NS_PRECONDITION(identifier, "null pointer");
    NS_PRECONDITION(((type == INTERFACEINFO_METHOD) || (type == INTERFACEINFO_SETTER) || (type == INTERFACEINFO_GETTER)), "invalid identifier type code");
    NS_PRECONDITION(infoout, "null pointer");
    NS_PRECONDITION(methodindex, "null pointer");

    rv = TclXPCOM_GetIdentifierFromObj(interp, identifier, infoout, &name);
    if (rv != TCL_OK)
    {
        return rv;
    }

    if (*infoout)
    {
        nameobj = Tcl_NewStringObj(name, -1);
        rv = TclXPCOM_GetIdentifierInfoFromInterface(interp, *infoout, nameobj, type, &idinfo);
        Tcl_DecrRefCount(nameobj);

    } else
    {
        rv = TclXPCOM_GetIdentifierInfoFromInterface(interp, interfaceinfo, identifier, type, &idinfo);
        if (rv == TCL_OK)
        {
            *infoout = interfaceinfo;
        } else
        {
            if (interfaceinfo != nsiclassinfo_info)
            {
                NS_ASSERTION((GetInterfaceRef(isupports)), "isupports entry doesn't exist in irefhash");

                cinfo = GetClassInfoFromIRef(GetInterfaceRef(isupports));
                if (cinfo)
                {
                    rv = TclXPCOM_GetIdentifierInfoFromClass(interp, cinfo, identifier, type, infoout, &idinfo);
                }
            }
        }
    }

    if (rv == TCL_OK)
    {
        rv = TclXPCOM_GetMethodIndex(interp, idinfo, type, methodindex);
    }

    return rv;
}


void
TclXPCOM_InitInterfaceRef(void)
{
    Tcl_InitHashTable(&irefhash, TCL_ONE_WORD_KEYS);
}

---