---

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


void *
CloneMemory(
    void   *ptr, 
    size_t  size 
)
{
    void *result;

    result = memmgr->Alloc(size);
    memcpy(result, ptr, size);

    return result;
}


int
TclXPCOM_CheckInterfaceIsReflectable(
    Tcl_Interp       *interp,       
    nsIInterfaceInfo *interfaceinfo,
    int               flags         
)
{
    PRBool scriptable;
    const char *name;

    NS_PRECONDITION(interp, "null pointer");
    NS_PRECONDITION(interfaceinfo, "null pointer");
    NS_PRECONDITION(!(flags & ~(FORCE_HIDDEN | FORCE_NOTXPCOM | FORCE_NOTSCRIPTABLE)), "invalid flags");

    if (!(flags & FORCE_NOTSCRIPTABLE))
    {
        interfaceinfo->IsScriptable(&scriptable);
        if (!scriptable)
        {
            interfaceinfo->GetNameShared(&name);
            Tcl_ResetResult(interp);
            Tcl_AppendResult(interp, "interface \"", name, "\" is not scriptable", NULL);
            return TCL_ERROR;
        }
    }
    return TCL_OK;
}


int
TclXPCOM_CheckMethodIsReflectable(
    Tcl_Interp       *interp,       
    nsIInterfaceInfo *interfaceinfo,
    PRUint16          methodindex,  
    int               flags         
)
{
    const char *name;
    const nsXPTMethodInfo *methodinfo;

    NS_PRECONDITION(interp, "null pointer");
    NS_PRECONDITION(interfaceinfo, "null pointer");
    NS_PRECONDITION(!(flags & ~(FORCE_HIDDEN | FORCE_NOTXPCOM | FORCE_NOTSCRIPTABLE)), "invalid flags");

    interfaceinfo->GetMethodInfo(methodindex, &methodinfo);

    if (methodinfo->IsNotXPCOM() && !(flags & FORCE_NOTXPCOM))
    {
        name = methodinfo->GetName();
        Tcl_ResetResult(interp);
        Tcl_AppendResult(interp, "\"", name, "\" is not an XPCOM method", NULL);
        return TCL_ERROR;
    }

    if (!(flags & FORCE_HIDDEN) && methodinfo->IsHidden())
    {
        name = methodinfo->GetName();
        Tcl_ResetResult(interp);
        Tcl_AppendResult(interp, "\"", name, "\" is a hidden method", NULL);
        return TCL_ERROR;
    }

    return TCL_OK;
}


int
isInInterface(
    nsIInterfaceInfo *interfaceinfo,
    nsIID            *iid           
)
{
    PRBool isiid;
    PRBool hasancestor;

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

    interfaceinfo->IsIID(iid, &isiid);
    interfaceinfo->HasAncestor(iid, &hasancestor);

    if (isiid || hasancestor)
    {
        return 1;
    }

    return 0;
}


Tcl_Obj *
TclXPCOM_ListInterfaceConstants(
    nsIInterfaceInfo *interfaceinfo 
)
{
    PRUint16 i;
    Tcl_Obj *result;
    InterfaceInfo *iinfo;

    NS_PRECONDITION(interfaceinfo, "null pointer");

    iinfo = GetInterfaceInfo(interfaceinfo);

    result = Tcl_NewListObj(0, NULL);
    for (i = 0; i < iinfo->constantcount; i++)
    {
        Tcl_ListObjAppendElement(NULL, result, Tcl_NewStringObj(iinfo->constantnames[i], -1));
    }

    return result;
}


Tcl_Obj *
TclXPCOM_ListInterfaceAttributes(
    nsIInterfaceInfo *interfaceinfo 
)
{
    PRUint16 i;
    Tcl_Obj *result;
    InterfaceInfo *iinfo;

    NS_PRECONDITION(interfaceinfo, "null pointer");

    iinfo = GetInterfaceInfo(interfaceinfo);

    result = Tcl_NewListObj(0, NULL);
    for (i = 0; i < iinfo->attributecount; i++)
    {
        Tcl_ListObjAppendElement(NULL, result, Tcl_NewStringObj(iinfo->attributes[i].name, -1));
    }

    return result;
}


Tcl_Obj *
TclXPCOM_ListInterfaceMethods(
    nsIInterfaceInfo *interfaceinfo 
)
{
    PRUint16 i;
    Tcl_Obj *result;
    InterfaceInfo *iinfo;

    NS_PRECONDITION(interfaceinfo, "null pointer");

    iinfo = GetInterfaceInfo(interfaceinfo);

    result = Tcl_NewListObj(0, NULL);
    for (i = 0; i < iinfo->methodcount; i++)
    {
        Tcl_ListObjAppendElement(NULL, result, Tcl_NewStringObj(iinfo->methods[i].name, -1));
    }

    return result;
}


Tcl_Obj *
TclXPCOM_ListClassMethods(
    ClassInfo *cinfo 
)
{
    PRUint16 i;
    Tcl_Obj *result;

    NS_PRECONDITION(cinfo, "null pointer");

    result = Tcl_NewListObj(0, NULL);
    for (i = 0; i < cinfo->methodcount; i++)
    {
        Tcl_ListObjAppendElement(NULL, result, Tcl_NewStringObj(cinfo->methods[i].idinfo.name, -1));
    }

    return result;
}


Tcl_Obj *
TclXPCOM_ListClassAttributes(
    ClassInfo *cinfo 
)
{
    PRUint16 i;
    Tcl_Obj *result;

    NS_PRECONDITION(cinfo, "null pointer");

    result = Tcl_NewListObj(0, NULL);
    for (i = 0; i < cinfo->attributecount; i++)
    {
        Tcl_ListObjAppendElement(NULL, result, Tcl_NewStringObj(cinfo->attributes[i].idinfo.name, -1));
    }

    return result;
}


Tcl_Obj *
GetType(
    nsIInterfaceInfo *interfaceinfo,
    PRUint16          methodindex,  
    nsXPTParamInfo   *paraminfo,    
    nsXPTType         type          
)
{
    nsXPTType arraytype;
    nsIInterfaceInfo *info;
    const char *name;
    Tcl_Obj *result;
    nsresult res;
    const nsXPTMethodInfo *methodinfo;
    char str[128];

    NS_PRECONDITION(interfaceinfo, "null pointer");
    NS_PRECONDITION(paraminfo, "null pointer");
    // type checked in default case

    switch (type.TagPart())
    {
        case nsXPTType::T_I8:
            result = Tcl_NewStringObj("int8", -1);
            break;
        case nsXPTType::T_I16:
            result = Tcl_NewStringObj("int16", -1);
            break;
        case nsXPTType::T_I32:
            result = Tcl_NewStringObj("int32", -1);
            break;
        case nsXPTType::T_I64:
            result = Tcl_NewStringObj("int64", -1);
            break;
        case nsXPTType::T_U8:
            result = Tcl_NewStringObj("uint8", -1);
            break;
        case nsXPTType::T_U16:
            result = Tcl_NewStringObj("uint16", -1);
            break;
        case nsXPTType::T_U32:
            result = Tcl_NewStringObj("uint32", -1);
            break;
        case nsXPTType::T_U64:
            result = Tcl_NewStringObj("uint64", -1);
            break;
        case nsXPTType::T_FLOAT:
            result = Tcl_NewStringObj("float", -1);
            break;
        case nsXPTType::T_DOUBLE:
            result = Tcl_NewStringObj("double", -1);
            break;
        case nsXPTType::T_BOOL:
            result = Tcl_NewStringObj("boolean", -1);
            break;
        case nsXPTType::T_CHAR:
            result = Tcl_NewStringObj("char", -1);
            break;
        case nsXPTType::T_WCHAR:
            result = Tcl_NewStringObj("wchar", -1);
            break;
        case nsXPTType::T_VOID:
            if (type.IsPointer())
            {
                result = Tcl_NewStringObj("pointer", -1);
            } else
            {
                result = Tcl_NewStringObj("void", -1);
            }
            break;
        case nsXPTType::T_IID:
            result = Tcl_NewStringObj("interface", -1);
            break;

        case nsXPTType::T_ASTRING:
        case nsXPTType::T_DOMSTRING:
        case nsXPTType::T_UTF8STRING:
        case nsXPTType::T_WCHAR_STR:
        case nsXPTType::T_PWSTRING_SIZE_IS:
            result = Tcl_NewStringObj("wstring", -1);
            break;

        case nsXPTType::T_CSTRING:
        case nsXPTType::T_CHAR_STR:
        case nsXPTType::T_PSTRING_SIZE_IS:
            result = Tcl_NewStringObj("string", -1);
            break;

        case nsXPTType::T_INTERFACE:
            res = interfaceinfo->GetInfoForParam(methodindex, paraminfo, &info);
            if (NS_SUCCEEDED(res))
            {
                info->GetNameShared(&name);
                result = Tcl_NewStringObj(name, -1);
                NS_RELEASE(info);
            } else {
                interfaceinfo->GetMethodInfo(methodindex, &methodinfo);
                interfaceinfo->GetNameShared(&name);
                sprintf(str, "GetInfoForParam Failed: Interface %s Method %s", name, methodinfo->GetName());
                NS_WARNING(str);

                result = Tcl_NewStringObj("nsISupports", -1);
            }
            break;

        case nsXPTType::T_INTERFACE_IS:
            result = Tcl_NewStringObj("nsISupports", -1);
            break;

        case nsXPTType::T_ARRAY:
            interfaceinfo->GetTypeForParam(methodindex, paraminfo, 1, &arraytype);
            result = Tcl_NewListObj(0, NULL);
            Tcl_ListObjAppendElement(NULL, result, Tcl_NewStringObj("list", -1));
            Tcl_ListObjAppendElement(NULL, result, GetType(interfaceinfo, methodindex, paraminfo, arraytype));
            break;

        default:
            NS_ERROR("invalid type");
            break;
    }

    return result;
}


Tcl_Obj *
GetParam(
    nsIInterfaceInfo *interfaceinfo,
    PRUint16          methodindex,  
    nsXPTParamInfo   *paraminfo     
)
{
    Tcl_Obj *result, *direction;

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

    result = Tcl_NewListObj(0, NULL);

    if (paraminfo->IsIn() && !paraminfo->IsDipper())
    {
        if (paraminfo->IsOut())
        {
            direction = Tcl_NewStringObj("inout", -1);
        } else
        {
            direction = Tcl_NewStringObj("in", -1);
        }
    } else
    {
        direction = Tcl_NewStringObj("out", -1);
    }

    Tcl_ListObjAppendElement(NULL, result, direction);
    Tcl_ListObjAppendElement(NULL, result, GetType(interfaceinfo, methodindex, paraminfo, paraminfo->GetType()));

    return result;
}


Tcl_Obj *
TclXPCOM_ListMethodArguments(
    nsIInterfaceInfo *interfaceinfo,
    PRUint16          methodindex   
)
{
    PRUint8 i;
    Tcl_Obj *result;
    MethodInfo *minfo;
    PRUint16 *tclparams;

    NS_PRECONDITION(interfaceinfo, "null pointer");

    minfo = GetMethodInfo(interfaceinfo, methodindex);
    tclparams = minfo->tclparams;

    result = Tcl_NewListObj(0, NULL);

    for (i = 0; i < minfo->paramcount; i++)
    {
        if ((tclparams[i] & PARAM_IS_SKIPPED) ||
            (tclparams[i] & PARAM_IS_RETVAL))
        {
            continue;
        }

        Tcl_ListObjAppendElement(NULL, result, GetParam(interfaceinfo, methodindex, &minfo->paraminfos[i]));
    }

    return result;
}


Tcl_Obj *
TclXPCOM_GetReturnValueType(
    nsIInterfaceInfo *interfaceinfo,
    IdentifierInfo   *idinfo        
)
{
    PRUint8 i;
    PRUint16 methodindex;
    MethodInfo *minfo;
    PRUint16 *tclparams;

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

    methodindex = idinfo->indices.methodindex;

    minfo = GetMethodInfo(interfaceinfo, methodindex);
    tclparams = minfo->tclparams;

    for (i = 0; i < minfo->paramcount; i++)
    {
        if (tclparams[i] & PARAM_IS_RETVAL)
        {
            return GetType(interfaceinfo, methodindex, &minfo->paraminfos[i], minfo->paraminfos[i].GetType());
        }
    }

    return Tcl_NewObj();
}


Tcl_Obj *
TclXPCOM_GetAttributeType(
    nsIInterfaceInfo *interfaceinfo,
    IdentifierInfo   *idinfo        
)
{
    PRUint16 methodindex;
    MethodInfo *minfo;
    PRUint16 *tclparams;

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

    if (idinfo->type & INTERFACEINFO_GETTER)
    {
        methodindex = idinfo->indices.attributeindices.getterindex;
    } else
    {
        methodindex = idinfo->indices.attributeindices.setterindex;
    }

    minfo = GetMethodInfo(interfaceinfo, methodindex);
    tclparams = minfo->tclparams;

    return GetType(interfaceinfo, methodindex, &minfo->paraminfos[0], minfo->paraminfos[0].GetType());
}

---