---

TclXPCOMClassInfo.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"
#include "nsQuickSort.h"


typedef struct ClassInfoList {
    ClassInfo            *cinfo;
    struct ClassInfoList *next;
} ClassInfoList;


typedef struct ClassInfoLookup {
    int              iidcount;
    nsIID            **iids;
    ClassInfo        *cinfo;
    struct ClassInfoLookup *next;
} ClassInfoLookup;


typedef struct InterfaceInfoList {
    InterfaceInfo *iinfo;
    struct InterfaceInfoList *next;
} InterfaceInfoList;


// XXX TODO: make classInfoList and classLookupTable threadsafe
ClassInfoList   *classInfoList;
ClassInfoLookup *classLookupTable;


void
TclXPCOM_InitClassInfo(void)
{
    classInfoList    = NULL;
    classLookupTable = NULL;
}


InterfaceInfoList *
NewInterfaceInfoList(
    nsIInterfaceInfo  *info, 
    InterfaceInfoList *next  
)
{
    NS_PRECONDITION(info, "null pointer");

    InterfaceInfoList *iilist;
    iilist = (InterfaceInfoList *)memmgr->Alloc(sizeof(InterfaceInfoList));
    iilist->iinfo = GetInterfaceInfo(info);
    iilist->next = next;
    return iilist;
}


void
FreeInterfaceInfoList(
    InterfaceInfoList *iilist 
)
{
    InterfaceInfoList *cur_elem, *temp;

    NS_PRECONDITION(iilist, "null pointer");

    for (cur_elem = iilist; cur_elem;)
    {
        temp = cur_elem;
        cur_elem = cur_elem->next;
        memmgr->Free(temp);
    }
}


InterfaceInfoList *
GetInterfaceInfoList(
    nsIInterfaceInfo  *info, 
    InterfaceInfoList *list  
)
{
    nsIInterfaceInfo *parent;
    InterfaceInfoList *iilist, *cur_elem;

    NS_PRECONDITION(info, "null pointer");

    for (cur_elem = list; cur_elem; cur_elem = cur_elem->next)
    {
        if (info == cur_elem->iinfo->info)
        {
            return NULL;
        }
    }

    info->GetParent(&parent);
    if (parent)
    {
        iilist = GetInterfaceInfoList(parent, list);
        NS_RELEASE(parent);
        return NewInterfaceInfoList(info, iilist);
    } else
    {
        return NewInterfaceInfoList(info, NULL);
    }
}


// given a list of iids,  returns an allocated array of addrefed interfaceinfos
// without any ancestor redundancies
ClassInfoSignature
NewClassInfoSignature(
    int     iidcount, 
    nsIID **iids      
)
{
    int i, j;
    nsIInterfaceInfo **infos;
    ClassInfoSignature signature;

    NS_PRECONDITION((iidcount > 0), "iidcount must be greater than 0");
    NS_PRECONDITION(iids, "null pointer");

    infos = (nsIInterfaceInfo **)memmgr->Alloc(sizeof(nsIInterfaceInfo *) * iidcount);
    memset(infos, 0, sizeof(nsIInterfaceInfo *) * iidcount);

    signature.infocount = iidcount;

    for (i = 0; i < iidcount; i++)
    {
        manager->GetInfoForIID(iids[i], &infos[i]);
        if (!infos[i])
        {
            (signature.infocount)--;
        }
    }

    for (i = 0; i < iidcount; i++)
    {
        if (!infos[i])
        {
            continue;
        }

        for (j = 0; j < iidcount; j++)
        {
            if (infos[j] && (i != j) && isInInterface(infos[i], iids[j]))
            {
                NS_RELEASE(infos[j]);
                infos[j] = NULL;
                (signature.infocount)--;
            }
        }
    }

    signature.infolist = (nsIInterfaceInfo **)memmgr->Alloc(sizeof(nsIInterfaceInfo *) * signature.infocount);

    j = 0;

    for (i = 0; i < iidcount; i++)
    {
        if (infos[i])
        {
            signature.infolist[j] = infos[i];
            j++;
        }
    }

    memmgr->Free(infos);

    return signature;
}


void
FreeClassInfoSignature(
    ClassInfoSignature signature 
)
{
    int i;

    NS_PRECONDITION((signature.infocount > 0), "infocount must be greater than 0");
    NS_PRECONDITION(signature.infolist, "null pointer");

    for (i = 0; i < signature.infocount; i++)
    {
        NS_RELEASE(signature.infolist[i]);
    }

    if (signature.infolist)
    {
        memmgr->Free(signature.infolist);
    }
}


InterfaceInfoList *
ExpandClassInfoSignature(
    ClassInfoSignature signature 
)
{
    int i;
    InterfaceInfoList *iilist, *cur_elem, *temp;

    NS_PRECONDITION((signature.infocount > 0), "infocount must be greater than 0");
    NS_PRECONDITION(signature.infolist, "null pointer");

    iilist = NULL;
    for (i = 0; i < signature.infocount; i++)
    {
        temp = GetInterfaceInfoList(signature.infolist[i], iilist);

        cur_elem = temp;
        while (cur_elem->next)
        {
            cur_elem = cur_elem->next;
        }

        cur_elem->next = iilist;
        iilist = temp;
    }

    return iilist;
}


int
ClassInfoSignaturesEqual(
    ClassInfoSignature signaturea,
    ClassInfoSignature signatureb 
)
{
    NS_PRECONDITION((signaturea.infocount > 0), "infocount must be greater than 0");
    NS_PRECONDITION(signaturea.infolist, "null pointer");
    NS_PRECONDITION((signatureb.infocount > 0), "infocount must be greater than 0");
    NS_PRECONDITION(signatureb.infolist, "null pointer");

    if (signaturea.infocount == signatureb.infocount)
    {
        if (!memcmp((void *)signaturea.infolist,
                    (void *)signatureb.infolist,
                    sizeof(nsIInterfaceInfo *) * signaturea.infocount))
        {
            return 1;
        }
    }
    return 0;
}


void
MarkDuplicateIdentifiersInArray(
    int                  idcount,
    ClassIdentifierInfo *idlist  
)
{
    int i, j;

    NS_PRECONDITION((idcount >= 0), "idcount must be positive");
    NS_PRECONDITION(!((idcount > 0) && !idlist), "null pointer");

    for (i = 0; i < idcount; i++)
    {
        if (idlist[i].qualified)
        {
            continue;
        }

        for (j = i + 1; j < idcount; j++)
        {
            if ((idlist[i].info == idlist[j].info) || idlist[j].qualified)
            {
                continue;
            }

            if (!strcmp(idlist[i].idinfo.name, idlist[j].idinfo.name))
            {
                idlist[j].qualified = 1;
                idlist[i].qualified = 1;
            }
        }
    }
}


void
MarkDuplicateIdentifiersBetweenArrays(
    int                  idcounta,
    ClassIdentifierInfo *idlista, 
    int                  idcountb,
    ClassIdentifierInfo *idlistb  
)
{
    int i, j;

    NS_PRECONDITION((idcounta >= 0), "idcounta must be positive");
    NS_PRECONDITION(!((idcounta > 0) && !idlista), "null pointer");
    NS_PRECONDITION((idcountb >= 0), "idcountb must be positive");
    NS_PRECONDITION(!((idcountb > 0) && !idlistb), "null pointer");

    for (i = 0; i < idcounta; i++)
    {
        for (j = 0; j < idcountb; j++)
        {
            if ((idlista[i].info == idlistb[j].info) || (idlista[i].qualified && idlistb[j].qualified))
            {
                continue;
            }

            if (!strcmp(idlista[i].idinfo.name, idlistb[j].idinfo.name))
            {
                idlista[i].qualified = 1;
                idlistb[j].qualified = 1;
            }
        }
    }
}


void
QualifyDuplicateIdentifiers(
    int                  idcount,
    ClassIdentifierInfo *idlist  
)
{
    int i;
    Tcl_Obj *identifierobj;
    char *identifier;

    NS_PRECONDITION((idcount >= 0), "idcount must be positive");
    NS_PRECONDITION(!((idcount > 0) && !idlist), "null pointer");

    for (i = 0; i < idcount; i++)
    {
        if (idlist[i].qualified)
        {
            identifierobj = TclXPCOM_NewIdentifierObj(idlist[i].info, idlist[i].idinfo.name);
            identifier = Tcl_GetString(identifierobj);
            idlist[i].idinfo.name = (char *)CloneMemory(identifier, sizeof(char) * (strlen(identifier) + 1));
            Tcl_DecrRefCount(identifierobj);
        }
    }
}


ClassIdentifierInfo *
AllocateClassIdentifierInfoArray(
    int idcount 
)
{
    ClassIdentifierInfo *cidinfo;

    NS_PRECONDITION((idcount >= 0), "idcount must be positive");

    if (idcount)
    {
        cidinfo = (ClassIdentifierInfo *)memmgr->Alloc(sizeof(ClassIdentifierInfo) * idcount + sizeof(char *));
        memset(cidinfo, 0, sizeof(ClassIdentifierInfo) * idcount + sizeof(char *));
    } else
    {
        cidinfo = NULL;
    }

    return cidinfo;
}


ClassInfo *
NewClassInfo(
    ClassInfoSignature signature 
)
{
    PRUint16 i, methodcount, attributecount;

    ClassInfo *cinfo;
    ClassIdentifierInfo *methods, *attributes;
    InterfaceInfoList *iilist, *cur_elem;

    NS_PRECONDITION((signature.infocount > 0), "infocount must be greater than 0");
    NS_PRECONDITION(signature.infolist, "null pointer");

    cinfo = (ClassInfo *)memmgr->Alloc(sizeof(ClassInfo));

    iilist = ExpandClassInfoSignature(signature);

    // count the number of methods and attributes
    attributecount = 0;
    methodcount    = 0;

    for (cur_elem = iilist; cur_elem; cur_elem = cur_elem->next)
    {
        attributecount += cur_elem->iinfo->attributecount - cur_elem->iinfo->baseattributeindex;
        methodcount    += cur_elem->iinfo->methodcount    - cur_elem->iinfo->basemethodindex;
    }

    // allocate memory for the attribute and method infos
    attributes = AllocateClassIdentifierInfoArray(attributecount);
    methods    = AllocateClassIdentifierInfoArray(methodcount);

    // fill attribute and method info
    attributecount = 0;
    methodcount    = 0;

    for (cur_elem = iilist; cur_elem; cur_elem = cur_elem->next)
    {
        for (i = cur_elem->iinfo->baseattributeindex; i < cur_elem->iinfo->attributecount; i++)
        {
            attributes[attributecount].info   = cur_elem->iinfo->info;
            attributes[attributecount].idinfo = cur_elem->iinfo->attributes[i];
            attributecount++;
        }

        for (i = cur_elem->iinfo->basemethodindex; i < cur_elem->iinfo->methodcount; i++)
        {
            methods[methodcount].info   = cur_elem->iinfo->info;
            methods[methodcount].idinfo = cur_elem->iinfo->methods[i];
            methodcount++;
        }
    }

    MarkDuplicateIdentifiersInArray(attributecount, attributes);
    MarkDuplicateIdentifiersInArray(methodcount, methods);
    MarkDuplicateIdentifiersBetweenArrays(attributecount, attributes, methodcount, methods);

    QualifyDuplicateIdentifiers(attributecount, attributes);
    QualifyDuplicateIdentifiers(methodcount, methods);

    FreeInterfaceInfoList(iilist);

    // fill in structure
    cinfo->signature      = signature;
    cinfo->methodcount    = methodcount;
    cinfo->attributecount = attributecount;
    cinfo->methods        = methods;
    cinfo->attributes     = attributes;

    return cinfo;
}


void
FreeClassInfo(
    ClassInfo *cinfo 
)
{
    PRUint16 i;

    NS_PRECONDITION(cinfo, "null pointer");

    FreeClassInfoSignature(cinfo->signature);

    for (i = 0; i < cinfo->methodcount; i++)
    {
        if (cinfo->methods[i].qualified)
        {
            memmgr->Free(cinfo->methods[i].idinfo.name);
        }
    }

    for (i = 0; i < cinfo->attributecount; i++)
    {
        if (cinfo->attributes[i].qualified)
        {
            memmgr->Free(cinfo->attributes[i].idinfo.name);
        }
    }

    if (cinfo->methods)
    {
        memmgr->Free(cinfo->methods);
    }

    if (cinfo->attributes)
    {
        memmgr->Free(cinfo->attributes);
    }

    memmgr->Free(cinfo);
}


ClassInfo *
FindMatchingClassInfo(
    ClassInfoSignature signature 
)
{
    ClassInfoList *cur_elem;

    NS_PRECONDITION((signature.infocount > 0), "infocount must be greater than 0");
    NS_PRECONDITION(signature.infolist, "null pointer");

    for (cur_elem = classInfoList; cur_elem; cur_elem = cur_elem->next)
    {
        if (ClassInfoSignaturesEqual(cur_elem->cinfo->signature, signature))
        {
            return cur_elem->cinfo;
        }
    }
    return NULL;
}


int
CompareNsIDs(
    const void *nsidPtra, 
    const void *nsidPtrb, 
    void       *userdata  
)
{
    return memcmp(*(void **)nsidPtra,
                  *(void **)nsidPtrb,
                  sizeof(nsID));
}


ClassInfo *
LookupClassInfo(
    int     iidcount, 
    nsIID **iids      
)
{
    int i, match;
    ClassInfoLookup *clist;

    NS_PRECONDITION((iidcount > 0), "iidcount must be greater than 0");
    NS_PRECONDITION(iids, "null pointer");

    for (clist = classLookupTable; clist; clist = clist->next)
    {
        if (clist->iidcount == iidcount)
        {
            match = 1;

            for (i = 0; i < iidcount; i++)
            {
                if (!clist->iids[i]->Equals(*iids[i]))
                {
                    match = 0;
                    break;
                }
            }

            if (match)
            {
                return clist->cinfo;
            }
        }
    }

    return NULL;
}


ClassInfo *
TclXPCOM_GetClassInfo(
    int     iidcount, 
    nsIID **iids      
)
{
    int i;
    ClassInfoLookup *cinfolookup;
    ClassInfoList *cinfolist;
    ClassInfo *cinfo;
    nsIID **iidlist;
    ClassInfoSignature signature;

    NS_PRECONDITION((iidcount > 0), "iidcount must be greater than 0");
    NS_PRECONDITION(iids, "null pointer");

    // sort the iids
    NS_QuickSort(iids, iidcount, sizeof(nsIID *), CompareNsIDs, NULL);

    cinfo = LookupClassInfo(iidcount, iids);

    if (cinfo)
    {
        return cinfo;
    }

    signature = NewClassInfoSignature(iidcount, iids);
    cinfo = FindMatchingClassInfo(signature);

    if (!cinfo)
    {
        cinfo = NewClassInfo(signature);
        cinfolist = (ClassInfoList *)memmgr->Alloc(sizeof(ClassInfoList));
        cinfolist->cinfo = cinfo;
        cinfolist->next  = classInfoList;
        classInfoList    = cinfolist;
    } else
    {
        FreeClassInfoSignature(signature);
    }

    cinfolookup = (ClassInfoLookup *)memmgr->Alloc(sizeof(ClassInfoLookup));
    cinfolookup->cinfo    = cinfo;
    cinfolookup->iidcount = iidcount;

    iidlist = (nsIID **)memmgr->Alloc(sizeof(nsIID *) * iidcount);
    for (i = 0; i < iidcount; i++)
    {
        iidlist[i] = (nsIID *)CloneMemory(iids[i], sizeof(nsIID));
    }

    cinfolookup->iids  = iidlist;
    cinfolookup->next  = classLookupTable;
    classLookupTable   = cinfolookup;

    return cinfo;
}


int
TclXPCOM_GetIdentifierInfoFromClass(
    Tcl_Interp        *interp,       
    ClassInfo         *cinfo,        
    Tcl_Obj           *identifier,   
    int                type,         
    nsIInterfaceInfo **interfaceinfo,
    IdentifierInfo   **idinfo        
)
{
    int rv;
    int index;
    int count;
    char *name;
    ClassIdentifierInfo *cidinfos;

    NS_PRECONDITION(interp, "null pointer");
    NS_PRECONDITION(cinfo, "null pointer");
    NS_PRECONDITION(identifier, "null pointer");
    NS_PRECONDITION(((type == INTERFACEINFO_METHOD) || (type == INTERFACEINFO_SETTER) || (type == INTERFACEINFO_GETTER)), "invalid identifier type code");
    NS_PRECONDITION(interfaceinfo, "null pointer");
    NS_PRECONDITION(idinfo, "null pointer");

    switch (type)
    {
        case INTERFACEINFO_METHOD:
            count    = cinfo->methodcount;
            cidinfos = cinfo->methods;
            name     = "method";
            break;

        case INTERFACEINFO_SETTER:
        case INTERFACEINFO_GETTER:
            count    = cinfo->attributecount;
            cidinfos = cinfo->attributes;
            name     = "attribute";
            break;
    }

    Tcl_ResetResult(interp);
    if (count)
    {
        rv = Tcl_GetIndexFromObjStruct(interp, identifier, (char **)&cidinfos[0].idinfo.name, sizeof(ClassIdentifierInfo), name, 0, &index);
        if (rv != TCL_OK)
        {
            return rv;
        }

    } else
    {
        Tcl_AppendResult(interp, "no ", name, "s in class", NULL);
        return TCL_ERROR;
    }

    *idinfo         = &cidinfos[index].idinfo;
    *interfaceinfo  =  cidinfos[index].info;
    return TCL_OK;
}

---