---

TclXPCOMInterfaceInfo.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 infohash threadsafe
Tcl_HashTable infohash;


IdentifierInfo
GetIdentifierInfo(
    nsIInterfaceInfo *interfaceinfo,
    PRUint16          methodindex   
)
{
    NS_PRECONDITION(interfaceinfo, "null pointer");

    IdentifierInfo idinfo;
    PRUint16 methodcount;
    const nsXPTMethodInfo *methodinfo;
    const nsXPTMethodInfo *methodinfo1;

    interfaceinfo->GetMethodInfo(methodindex, &methodinfo);
    interfaceinfo->GetMethodCount(&methodcount);

    idinfo.name = (char *)methodinfo->GetName();
    idinfo.type = 0;

    if (methodinfo->IsGetter())
    {
        idinfo.type |= INTERFACEINFO_GETTER;
        idinfo.indices.attributeindices.getterindex = methodindex;

        if (methodindex + 1 < methodcount)
        {
            interfaceinfo->GetMethodInfo(methodindex + 1, &methodinfo1);
            if (methodinfo1->IsSetter())
            {
                idinfo.type |= INTERFACEINFO_SETTER;
                idinfo.indices.attributeindices.setterindex = methodindex + 1;
            }
        }
    } else if (methodinfo->IsSetter())
    {
        idinfo.type |= INTERFACEINFO_SETTER;
        idinfo.indices.attributeindices.setterindex = methodindex;
    } else
    {
        idinfo.type |= INTERFACEINFO_METHOD;
        idinfo.indices.methodindex = methodindex;
    }

    return idinfo;
}


InterfaceInfo *
NewInterfaceInfo(
    nsIInterfaceInfo *interfaceinfo 
)
{
    PRUint16 i;

    InterfaceInfo *iinfo;
    nsIInterfaceInfo *parent;

    PRUint16 imethodcount,   baseimethodindex;
    PRUint16 constantcount,  baseconstantindex;
    PRUint16 methodcount,    basemethodindex;
    PRUint16 attributecount, baseattributeindex;

    MethodInfo *imethods;
    Tcl_Obj    **constantvalues;

    IdentifierInfo      idinfo;
    IdentifierInfo      *methods;
    IdentifierInfo      *attributes;
    const char          **constantnames;

    const nsXPTConstant   *constantinfo;


    NS_PRECONDITION(interfaceinfo, "null pointer");

    iinfo = (InterfaceInfo *)memmgr->Alloc(sizeof(InterfaceInfo));

    interfaceinfo->GetParent(&parent);
    if (parent)
    {
        parent->GetMethodCount(&baseimethodindex);
        parent->GetConstantCount(&baseconstantindex);
    } else
    {
        baseimethodindex = 0;
        baseconstantindex = 0;
    }

    interfaceinfo->GetMethodCount(&imethodcount);
    interfaceinfo->GetConstantCount(&constantcount);

    if (imethodcount - baseimethodindex)
    {
        imethods = (MethodInfo *)memmgr->Alloc(sizeof(MethodInfo) * (imethodcount - baseimethodindex));
        memset(imethods, 0, sizeof(MethodInfo) * (imethodcount - baseimethodindex));
    } else
    {
        imethods = NULL;
    }

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

    for (i = 0; i < imethodcount; i++)
    {
        idinfo = GetIdentifierInfo(interfaceinfo, i);

        if (idinfo.type & INTERFACEINFO_METHOD)
        {
            methodcount++;
            if (i < baseimethodindex)
            {
                basemethodindex++;
            }

        } else
        {
            if ((idinfo.type & INTERFACEINFO_GETTER)
                && (idinfo.type & INTERFACEINFO_SETTER))
            {
                i++;
            }

            attributecount++;
            if (i < baseimethodindex)
            {
                baseattributeindex++;
            }
        }
    }

    // allocate memory for the names and info pointers
    if (attributecount)
    {
        attributes = (IdentifierInfo *)memmgr->Alloc(sizeof(IdentifierInfo) * attributecount + sizeof(char *));
        attributes[attributecount].name = NULL;
    } else
    {
        attributes = NULL;
    }

    if (methodcount)
    {
        methods = (IdentifierInfo *)memmgr->Alloc(sizeof(IdentifierInfo) * methodcount + sizeof(char *));
        methods[methodcount].name = NULL;
    } else
    {
        methods = NULL;
    }

    // create attribute and method names
    attributecount = 0;
    methodcount = 0;

    for (i = 0; i < imethodcount; i++)
    {
        idinfo = GetIdentifierInfo(interfaceinfo, i);

        if (idinfo.type & INTERFACEINFO_METHOD)
        {
            methods[methodcount] = idinfo;
            methodcount++;
        } else
        {
            if ((idinfo.type & INTERFACEINFO_GETTER)
                && (idinfo.type & INTERFACEINFO_SETTER))
            {
                i++;
            }

            attributes[attributecount] = idinfo;
            attributecount++;
        }
    }

    // setup constants
    if (constantcount)
    {
        constantnames = (const char **)memmgr->Alloc(sizeof(char *) * (constantcount + 1));
        constantnames[constantcount] = NULL;
    } else
    {
        constantnames = NULL;
    }

    if (constantcount - baseconstantindex)
    {
        constantvalues = (Tcl_Obj **)memmgr->Alloc(sizeof(Tcl_Obj *) * (constantcount - baseconstantindex));
        memset(constantvalues, 0, sizeof(Tcl_Obj *) * (constantcount - baseconstantindex));
    } else
    {
        constantvalues = NULL;
    }

    for (i = 0; i < constantcount; i++)
    {
        interfaceinfo->GetConstant(i, &constantinfo);
        constantnames[i] = constantinfo->GetName();
    }


    NS_ADDREF(interfaceinfo);

    // fill in structure
    iinfo->info               = interfaceinfo;
    iinfo->parentinfo         = parent;

    iinfo->imethodcount       = imethodcount;
    iinfo->methodcount        = methodcount;
    iinfo->attributecount     = attributecount;
    iinfo->constantcount      = constantcount;

    iinfo->baseimethodindex   = baseimethodindex;
    iinfo->baseconstantindex  = baseconstantindex;
    iinfo->baseattributeindex = baseattributeindex;
    iinfo->basemethodindex    = basemethodindex;

    iinfo->imethods           = imethods;
    iinfo->methods            = methods;
    iinfo->attributes         = attributes;
    iinfo->constantnames      = (char **)constantnames;
    iinfo->constantvalues     = constantvalues;

    return iinfo;
}


void
FreeInterfaceInfo(
    InterfaceInfo *iinfo 
)
{
    PRUint16 i;
    MethodInfo *minfo;

    NS_PRECONDITION(iinfo, "null pointer");

    for (i = 0; i < iinfo->imethodcount; i++)
    {
        minfo = &iinfo->imethods[i];
        if (minfo->tclparams)
        {
            memmgr->Free(minfo->tclparams);
            memmgr->Free(minfo->paraminfos);
        }
    }

    for (i = 0; i < iinfo->constantcount; i++)
    {
        if (iinfo->constantvalues[i])
        {
            Tcl_DecrRefCount(iinfo->constantvalues[i]);
        }
    }

    if (iinfo->imethods)
    {
        memmgr->Free(iinfo->imethods);
    }

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

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

    if (iinfo->constantnames)
    {
        memmgr->Free(iinfo->constantnames);
    }

    if (iinfo->constantvalues)
    {
        memmgr->Free(iinfo->constantvalues);
    }

    NS_RELEASE(iinfo->info);

    if (iinfo->parentinfo)
    {
        NS_RELEASE(iinfo->parentinfo);
    }

    memmgr->Free(iinfo);
}


//               Dependent param (nsISupports, array)
//
//                      in      out     in/out
//                   ---------------------------
//                   |
// Independent   in  |  skip   *reqd.   *skip
//  param            |
//                   |
//  (nsIID,      out |   ??     skip     ??
//   length)         |
//                   |
//            in/out |  reqd.   reqd.   skip
//                   |
//                   |
//
//  ?? = combination makes no sense
//
//   * = calling function assumes the dependent param
//       was correctly set, i.e.
//         the returned nsISupports is of the given nsIID or
//         the returned array is of the given length
void
CalculateSharedParams(
    nsXPTParamInfo *indep,     
    nsXPTParamInfo *dep,       
    PRUint8         indepindex,
    PRUint8         depindex,  
    PRUint16       *tclparams  
)
{
    NS_PRECONDITION(indep, "null pointer");
    NS_PRECONDITION(dep, "null pointer");
    NS_PRECONDITION(tclparams, "null pointer");

    if (dep->IsIn())
    {
        tclparams[indepindex] |= PARAM_IS_SKIPPED_IN;
    }

    if (dep->IsOut())
    {
        tclparams[indepindex] |= PARAM_IS_SKIPPED_OUT;
    }

    if (indep->IsIn() && dep->IsIn())
    {
        if (tclparams[indepindex] & PARAM_IS_SHARED_IN)
        {
            tclparams[depindex] |= PARAM_IS_SHARED_IN;
        }
        tclparams[indepindex] |= PARAM_IS_SHARED_IN;
    }

    if (indep->IsOut() && dep->IsOut())
    {
        if (tclparams[indepindex] & PARAM_IS_SHARED_OUT)
        {
            tclparams[depindex] |= PARAM_IS_SHARED_OUT;
        }
        tclparams[indepindex] |= PARAM_IS_SHARED_OUT;
    }

    if (indep->IsIn() && !indep->IsOut() && dep->IsOut())
    {
        tclparams[depindex] |= PARAM_IS_SHARED_OUT;
    }
}


PRUint8
PrepareParamInfo(
    PRUint16         *tclparams,    
    nsXPTParamInfo   *paraminfos,   
    PRUint8           paramcount,   
    nsIInterfaceInfo *interfaceinfo,
    PRUint16          methodindex   
)
{
    PRUint8 i;
    PRUint8 tclparamcount;
    PRUint8 iidindex, lengthindex, sizeindex;

    NS_PRECONDITION(tclparams, "null pointer");
    NS_PRECONDITION(paraminfos, "null pointer");
    NS_PRECONDITION(interfaceinfo, "null pointer");

    for (i = 0; i < paramcount; i++)
    {
        tclparams[i] = 0;

        if (!paraminfos[i].IsIn())
        {
            tclparams[i] |= PARAM_IS_SKIPPED_IN;
        }

        if (!paraminfos[i].IsOut())
        {
            tclparams[i] |= PARAM_IS_SKIPPED_OUT;
        }
    }

    for (i = 0; i < paramcount; i++)
    {
        if (paraminfos[i].GetType().IsDependent())
        {
            if (paraminfos[i].GetType().IsInterfacePointer())
            {
                interfaceinfo->GetInterfaceIsArgNumberForParam(methodindex, &paraminfos[i], &iidindex);
                CalculateSharedParams(&paraminfos[iidindex], &paraminfos[i], iidindex, i, tclparams);
            } else
            {
                interfaceinfo->GetLengthIsArgNumberForParam(methodindex, &paraminfos[i], 0, &lengthindex);
                interfaceinfo->GetSizeIsArgNumberForParam(methodindex, &paraminfos[i], 0, &sizeindex);
                CalculateSharedParams(&paraminfos[lengthindex], &paraminfos[i], lengthindex, i, tclparams);
                if (lengthindex != sizeindex)
                {
                    CalculateSharedParams(&paraminfos[sizeindex], &paraminfos[i], sizeindex, i, tclparams);
                }
            }
        }
    }

    tclparamcount = 0;

    for (i = 0; i < paramcount; i++)
    {
        if ((tclparams[i] & PARAM_IS_SKIPPED_IN) && (tclparams[i] & PARAM_IS_SKIPPED_OUT))
        {
            tclparams[i] |= PARAM_IS_SKIPPED;
        } else
        {
            if (paraminfos[i].IsRetval())
            {
                tclparams[i] |= PARAM_IS_RETVAL;
            } else
            {
                tclparams[i] |= (tclparamcount & PARAM_INDEX_MASK);
                tclparamcount++;
            }
        }
    }

    return tclparamcount;
}


void
PrepareMethodInfo(
    nsIInterfaceInfo *interfaceinfo,
    MethodInfo       *minfo,        
    PRUint16          methodindex   
)
{
    PRUint8 i, paramcount;
    const nsXPTMethodInfo *methodinfo;

    NS_PRECONDITION(interfaceinfo, "null pointer");
    NS_PRECONDITION(minfo, "null pointer");

    if (minfo->tclparams)
    {
        return;
    }

    interfaceinfo->GetMethodInfo(methodindex, &methodinfo);
    paramcount = methodinfo->GetParamCount();

    minfo->paramcount = paramcount;
    minfo->paraminfos = (nsXPTParamInfo *)memmgr->Alloc(sizeof(nsXPTParamInfo) * paramcount);
    minfo->tclparams  =       (PRUint16 *)memmgr->Alloc(sizeof(PRUint16) * paramcount);

    for (i = 0; i < paramcount; i++)
    {
        minfo->paraminfos[i] = methodinfo->GetParam(i);
    }

    minfo->tclparamcount = PrepareParamInfo(minfo->tclparams, minfo->paraminfos, paramcount, interfaceinfo, methodindex);
}


void
PrepareInterfaceConstantValue(
    nsIInterfaceInfo *interfaceinfo,
    Tcl_Obj         **constantvalue,
    PRUint16          constantindex 
)
{
    const nsXPTCMiniVariant *variant;
    const nsXPTConstant     *constantinfo;
    nsXPTType type;

    NS_PRECONDITION(interfaceinfo, "null pointer");
    NS_PRECONDITION(constantvalue, "null pointer");

    if (*constantvalue)
    {
        return;
    }

    interfaceinfo->GetConstant(constantindex, &constantinfo);
    variant = constantinfo->GetValue();
    type = constantinfo->GetType();

    // ignore nsresult,  assumed to be successful
    Native2Tcl((void **)&variant, (void *)variant, &type, NULL, 0, NULL, constantvalue);
    Tcl_IncrRefCount(*constantvalue);
}


InterfaceInfo *
GetInterfaceInfo(
    nsIInterfaceInfo *interfaceinfo 
)
{
    int newentry;
    Tcl_HashEntry *entry;

    NS_PRECONDITION(interfaceinfo, "null pointer");

    entry = Tcl_CreateHashEntry(&infohash, (char *)interfaceinfo, &newentry);
    if (newentry)
    {
        Tcl_SetHashValue(entry, NewInterfaceInfo(interfaceinfo));
    }

    return (InterfaceInfo *)Tcl_GetHashValue(entry);
}


MethodInfo *
GetMethodInfo(
    nsIInterfaceInfo *interfaceinfo,
    PRUint16          methodindex   
)
{
    InterfaceInfo *iinfo;

    NS_PRECONDITION(interfaceinfo, "null pointer");

    iinfo = GetInterfaceInfo(interfaceinfo);

    while (methodindex < iinfo->baseimethodindex)
    {
        iinfo = GetInterfaceInfo(iinfo->parentinfo);
    }

    PrepareMethodInfo(interfaceinfo, &iinfo->imethods[methodindex - iinfo->baseimethodindex], methodindex);
    return &iinfo->imethods[methodindex - iinfo->baseimethodindex];
}


Tcl_Obj *
GetInterfaceConstantValue(
    nsIInterfaceInfo *interfaceinfo,
    PRUint16          constantindex 
)
{
    InterfaceInfo *iinfo;
    iinfo = GetInterfaceInfo(interfaceinfo);

    NS_PRECONDITION(interfaceinfo, "null pointer");

    while (constantindex < iinfo->baseconstantindex)
    {
        iinfo = GetInterfaceInfo(iinfo->parentinfo);
    }

    PrepareInterfaceConstantValue(interfaceinfo, &iinfo->constantvalues[constantindex - iinfo->baseconstantindex], constantindex);
    return iinfo->constantvalues[constantindex - iinfo->baseconstantindex];
}


int
TclXPCOM_GetIdentifierInfoFromInterface(
    Tcl_Interp       *interp,       
    nsIInterfaceInfo *interfaceinfo,
    Tcl_Obj          *identifier,   
    int               type,         
    IdentifierInfo  **idinfo        
)
{
    int rv;
    int index;
    PRUint16 count;
    char *name;
    IdentifierInfo *idinfos;
    InterfaceInfo  *iinfo;

    NS_PRECONDITION(interp, "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(idinfo, "null pointer");

    iinfo = GetInterfaceInfo(interfaceinfo);

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

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

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

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

    *idinfo = &idinfos[index];
    return TCL_OK;
}


int 
TclXPCOM_GetMethodIndex(
    Tcl_Interp       *interp,       
    IdentifierInfo   *idinfo,       
    int               type,         
    PRUint16         *methodindex   
)
{
    PRUint16 index;

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

    switch (type)
    {
        case INTERFACEINFO_METHOD:
            index = idinfo->indices.methodindex;
            break;

        case INTERFACEINFO_GETTER:
            index = idinfo->indices.attributeindices.getterindex;
            if (!(idinfo->type & INTERFACEINFO_GETTER))
            {
                Tcl_AppendResult(interp, "attribute is write-only", NULL);
                return TCL_ERROR;
            }
            break;

        case INTERFACEINFO_SETTER:
            index = idinfo->indices.attributeindices.setterindex;
            if (!(idinfo->type & INTERFACEINFO_SETTER))
            {
                Tcl_AppendResult(interp, "attribute is read-only", NULL);
                return TCL_ERROR;
            }
            break;
    }

    *methodindex = index;
    return TCL_OK;
}


int
TclXPCOM_GetConstant(
    Tcl_Interp       *interp,       
    nsIInterfaceInfo *interfaceinfo,
    Tcl_Obj          *constantname, 
    Tcl_Obj         **result        
)
{
    int rv;
    int index;
    InterfaceInfo *iinfo;

    NS_PRECONDITION(interp, "null pointer");
    NS_PRECONDITION(interfaceinfo, "null pointer");
    NS_PRECONDITION(constantname, "null pointer");
    NS_PRECONDITION(result, "null pointer");

    iinfo = GetInterfaceInfo(interfaceinfo);

    Tcl_ResetResult(interp);
    if (iinfo->constantcount)
    {
        rv = Tcl_GetIndexFromObj(interp, constantname, iinfo->constantnames, "constant", 0, &index);
        if (rv != TCL_OK)
        {
            return rv;
        }

    } else
    {
        Tcl_AppendResult(interp, "no constants in interface", NULL);
        return TCL_ERROR;
    }

    *result = GetInterfaceConstantValue(interfaceinfo, (PRUint16)index);
    return TCL_OK;
}


int
IsInInterface(
    nsIInterfaceInfo *infoa,
    nsIInterfaceInfo *infob 
)
{
    InterfaceInfo *iinfo;

    NS_PRECONDITION(infoa, "null pointer");
    NS_PRECONDITION(infob, "null pointer");

    do
    {
        if (infoa == infob)
        {
            return 1;
        }

        iinfo = GetInterfaceInfo(infob);
        infob = iinfo->parentinfo;

    } while (infob);

    return 0;
}


void
TclXPCOM_InitInterfaceInfo(void)
{
    Tcl_InitHashTable(&infohash, TCL_ONE_WORD_KEYS);
}

---