---

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


int
GetInterfaceInfoFromObj(
    Tcl_Interp        *interp,       
    Tcl_Obj           *objPtr,       
    nsIInterfaceInfo **interfaceinfo 
)
{
    int rv;
    nsresult res;
    nsIID *iid;

    NS_PRECONDITION(interp, "null pointer");
    NS_PRECONDITION(objPtr, "null pointer");
    NS_PRECONDITION(interfaceinfo, "null pointer");

    rv = TclXPCOM_GetNsIDFromObj(interp, objPtr, (nsID **)&iid);

    if (rv == TCL_OK)
    {
        res = manager->GetInfoForIID(iid, interfaceinfo);
    }

    if ((rv != TCL_OK) || (NS_FAILED(res)))
    {
        Tcl_ResetResult(interp);
        Tcl_AppendResult(interp, "unknown interface \"", Tcl_GetString(objPtr), "\"", NULL);
        return TCL_ERROR;
    }

    return TCL_OK;
}


int
VerifyNsIDObj(
    Tcl_Interp *interp, 
    Tcl_Obj    *iidobj, 
    int         flags   
)
{
    int rv;
    nsIInterfaceInfo *info;

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

    rv = GetInterfaceInfoFromObj(interp, iidobj, &info);

    if (rv == TCL_OK)
    {
        rv = TclXPCOM_CheckInterfaceIsReflectable(interp, info, flags);
        NS_RELEASE(info);
    }

    return rv;
}


int
GetClassInfoFromInterfaceList(
    Tcl_Interp *interp,     
    Tcl_Obj    *interfaces, 
    int         flags,      
    ClassInfo **cinfo       
)
{
    int rv;
    int i;
    Tcl_Obj **iidobjlist;
    nsIID **iids;
    int iidcount;
    const nsIID *iid;

    NS_PRECONDITION(interp, "null pointer");
    //no precondition on interfaces
    NS_PRECONDITION(!(flags & ~(FORCE_HIDDEN | FORCE_NOTXPCOM | FORCE_NOTSCRIPTABLE)), "invalid flags");
    NS_PRECONDITION(cinfo, "null pointer");
 
    if (interfaces)
    {
        // verify interface list is valid
        rv = Tcl_ListObjGetElements(interp, interfaces, &iidcount, &iidobjlist);
        if (rv != TCL_OK)
        {
            return rv;
        }
    } else
    {
        iidcount = 0;
    }
    
    if (iidcount)
    {
        for (i = 0; i < iidcount; i++)
        {
            rv = VerifyNsIDObj(interp, iidobjlist[i], flags);
            if (rv != TCL_OK)
            {
                return rv;
            }
        }
        
        iids = (nsIID **)memmgr->Alloc(sizeof(nsIID *) * iidcount);
        for (i = 0; i < iidcount; i++)
        {
            TclXPCOM_GetNsIDFromObj(interp, iidobjlist[i], &iids[i]);
        }
        
        *cinfo = TclXPCOM_GetClassInfo(iidcount, iids);
        memmgr->Free(iids);
    } else
    {
        iid = &nsisupports_iid;
        *cinfo = TclXPCOM_GetClassInfo(1, (nsIID **)&iid);
    }

    return TCL_OK;
}


int
GetOverrideSwitches(
    ClientData     clientData,
    Tcl_Interp    *interp,    
    int            objc,      
    Tcl_Obj *CONST objv[],    
    int           *baseindex, 
    int           *flags      
)
{
    int i;
    int index;
    char *name;

    static char *switches[] = {"-hidden", "-notxpcom", "-noscript", "--", NULL};
    enum options {EVAL_HIDDEN, EVAL_NOTXPCOM, EVAL_NOTSCRIPTABLE, EVAL_LAST};

    // no precondition on clientData
    NS_PRECONDITION(interp, "null pointer");
    NS_PRECONDITION((objc >= 0), "objc must be positive");
    NS_PRECONDITION(objv, "null pointer");
    NS_PRECONDITION(baseindex, "null pointer");
    NS_PRECONDITION((*baseindex >= 0), "baseindex must be positive");
    NS_PRECONDITION(flags, "null pointer");

    *flags = 0;
    
    for (i = *baseindex; i < objc; i++)
    {
        name = Tcl_GetString(objv[i]);
        
        if (name[0] != '-')
        {
            break;
        }
        
        if (Tcl_GetIndexFromObj(interp, objv[i], switches, "switch", TCL_EXACT, &index) != TCL_OK)
        {
            return TCL_ERROR;
        }
        
        switch (index)
        {
            case EVAL_HIDDEN:
                *flags |= FORCE_HIDDEN;
                break;
            
            case EVAL_NOTXPCOM:
                *flags |= FORCE_NOTXPCOM;
                break;

            case EVAL_NOTSCRIPTABLE:
                *flags |= FORCE_NOTSCRIPTABLE;
                break;
            
            case EVAL_LAST:
                i++;
                goto endOfForLoop;
        }
    }
    
endOfForLoop:

    *baseindex = i;

    return TCL_OK;
}


int
TclXPCOM_WrapObjCmd(
    ClientData     clientData,
    Tcl_Interp    *interp,    
    int            objc,      
    Tcl_Obj *CONST objv[]     
)
{
    int rv;
    int i;
    int flags;
    Tcl_Obj *interfaces;

    int bindlistcount;
    Tcl_Obj **bindlist;

    TclXPCOMComponent *component;
    ClassInfo *cinfo;

    // no precondition on clientData
    NS_PRECONDITION(interp, "null pointer");
    NS_PRECONDITION((objc >= 0), "objc must be positive");
    NS_PRECONDITION(objv, "null pointer");

    i = 1;

    rv = GetOverrideSwitches(clientData, interp, objc, objv, &i, &flags);
    if (rv != TCL_OK)
    {
        return rv;
    }

    if (objc - i > 2)
    {
        Tcl_WrongNumArgs(interp, 2, objv, "?options? ?interfaces? ?bindings?");
        return TCL_ERROR;
    }
    
    if (objc - i > 0)
    {
        interfaces = objv[i];
    } else
    {
        interfaces = NULL;
    }

    rv = GetClassInfoFromInterfaceList(interp, interfaces, flags, &cinfo);
    if (rv != TCL_OK)
    {
        return rv;
    }

    if (objc - i > 1)
    {
        // verify binding list is valid and contains an even number of elements
        rv = Tcl_ListObjGetElements(interp, objv[i+1], &bindlistcount, &bindlist);
        if (rv != TCL_OK)
        {
            return rv;
        }
    } else
    {
        bindlistcount = 0;
    }

    if (bindlistcount & 1)
    {
        Tcl_ResetResult(interp);
        Tcl_AppendResult(interp, "binding list must have an even number of elements", NULL);
        return TCL_ERROR;
    }

    component = NewTclXPCOMComponent(interp, Tcl_GetCurrentThread(), cinfo);

    // process each binding
    for (i = 0; i < bindlistcount; i = i + 2)
    {
        rv = BindScript(interp, component, bindlist[i], bindlist[i+1], flags);
        if (rv != TCL_OK)
        {
            FreeTclXPCOMComponent(component);
            return rv;
        }
    }

    char str[128];
    sprintf(str, "Created   Component %p, Refcount: 0", component);
    NS_WARNING(str);

    Tcl_SetObjResult(interp, TclXPCOM_NewISupportsObj((nsISupports *)(nsXPTCStubBase *)component->stubs[0], nsisupports_info));

    return TCL_OK;
}


int
TclXPCOM_InvokeObjCmd(
    ClientData     clientData,
    Tcl_Interp    *interp,    
    int            objc,      
    Tcl_Obj *CONST objv[]     
)
{
    int rv;
    int i, baseindex, flags, type;
    PRUint16 methodindex;

    nsISupports      *isupports, *ref;
    nsIInterfaceInfo *interfaceinfo, *queryinfo;
    InterfaceRef     *iref;
    MethodInfo       *minfo;
    Tcl_Obj          *args;

    // no precondition on clientData
    NS_PRECONDITION(interp, "null pointer");
    NS_PRECONDITION((objc >= 0), "objc must be positive");
    NS_PRECONDITION(objv, "null pointer");

    i = (int)clientData;

    rv = GetOverrideSwitches(clientData, interp, objc, objv, &i, &flags);
    if (rv != TCL_OK)
    {
        return rv;
    }
    
    if (objc - i < 2)
    {
        Tcl_WrongNumArgs(interp, 2, objv, "?options? interface command ?args?");
        return TCL_ERROR;
    }

    rv = TclXPCOM_GetISupportsFromObj(interp, objv[i], &isupports, &interfaceinfo);
    if (rv != TCL_OK)
    {
        return rv;
    }

    i++;
    baseindex = i;

    if (!strcmp(Tcl_GetString(objv[i]), "set"))
    {
        if (objc - i == 1)
        {
            Tcl_WrongNumArgs(interp, 1, objv, "attribute ?value?");
            return TCL_ERROR;

        } else if (objc - i == 2)
        {
            type = INTERFACEINFO_GETTER;
        } else
        {
            type = INTERFACEINFO_SETTER;
        }

        i++;
    } else
    {
        type = INTERFACEINFO_METHOD;
    }

    rv = GetMethodFromIRef(interp, isupports, interfaceinfo, objv[i], type, &queryinfo, &methodindex);
    if (rv != TCL_OK)
    {
        return rv;
    }

    rv = TclXPCOM_CheckInterfaceIsReflectable(interp, queryinfo, flags);
    if (rv != TCL_OK)
    {
        return rv;
    }

    rv = TclXPCOM_CheckMethodIsReflectable(interp, queryinfo, methodindex, flags);
    if (rv != TCL_OK)
    {
        return rv;
    }

    iref = GetInterfaceRef(isupports);
    NS_ASSERTION(iref, "isupports entry doesn't exist in irefhash");

    rv = QueryInterfaceIRef(interp, iref, queryinfo, &ref);
    if (rv != TCL_OK)
    {
        return rv;
    }

    i++;

    minfo = GetMethodInfo(queryinfo, methodindex);
    if ((objc - i) != minfo->tclparamcount)
    {
        args = TclXPCOM_ListMethodArguments(queryinfo, methodindex);
        Tcl_WrongNumArgs(interp, i - baseindex, &objv[baseindex], Tcl_GetString(args));
        Tcl_DecrRefCount(args);
        return TCL_ERROR;
    }

    rv = TclXPCOM_Invoke(interp, &objv[i], ref, queryinfo, methodindex);

    return rv;
}


int
TclXPCOM_InfoObjCmd(
    ClientData     clientData,
    Tcl_Interp    *interp,    
    int            objc,      
    Tcl_Obj *CONST objv[]     
)
{
    int   rv;
    int   index;
    nsIInterfaceInfo   *interfaceinfo;
    ClassInfo          *cinfo;
    IdentifierInfo     *idinfo;
    
    static char *commands[] = {"constants", "attributes", "methods", 
                        "args", "type", "retval",
                        "servicemanager", NULL};

    enum command {XPCOM_CONSTANTS, XPCOM_ATTRIBUTES, XPCOM_METHODS,
                  XPCOM_ARGS, XPCOM_TYPE, XPCOM_RETVAL,
                  XPCOM_SERVICEMANAGER};

    // no precondition on clientData
    NS_PRECONDITION(interp, "null pointer");
    NS_PRECONDITION((objc >= 0), "objc must be positive");
    NS_PRECONDITION(objv, "null pointer");

    if (objc < 2)
    {
        Tcl_WrongNumArgs(interp, 2, objv, "option ?arg arg ...?");
        return TCL_ERROR;
    }

    rv = Tcl_GetIndexFromObj(interp, objv[1], commands, "option", 0, &index);
    if (rv != TCL_OK)
    {
        return rv;
    }

    switch (index)
    {
        case XPCOM_SERVICEMANAGER:
            if (objc != 2)
            {
                Tcl_WrongNumArgs(interp, 2, objv, NULL);
                return TCL_ERROR;
            }

            Tcl_SetObjResult(interp, TclXPCOM_NewISupportsObj(servmanager, nsiservicemanager_info));
            return TCL_OK;
            break;

        case XPCOM_TYPE:
            if (objc != 4)
            {
                Tcl_WrongNumArgs(interp, 2, objv, "interfaces attribute");
                return TCL_ERROR;
            }

            rv = GetClassInfoFromInterfaceList(interp, objv[2], FORCE_NOTSCRIPTABLE, &cinfo);
            if (rv != TCL_OK)
            {
                return rv;
            }

            rv = TclXPCOM_GetIdentifierInfoFromClass(interp, cinfo, objv[3], INTERFACEINFO_GETTER, &interfaceinfo, &idinfo);
            if (rv != TCL_OK)
            {
                return rv;
            }
            
            Tcl_SetObjResult(interp, TclXPCOM_GetAttributeType(interfaceinfo, idinfo));
            return TCL_OK;
            break;

        case XPCOM_RETVAL:
            if (objc != 4)
            {
                Tcl_WrongNumArgs(interp, 2, objv, "interfaces method");
                return TCL_ERROR;
            }

            rv = GetClassInfoFromInterfaceList(interp, objv[2], FORCE_NOTSCRIPTABLE, &cinfo);
            if (rv != TCL_OK)
            {
                return rv;
            }

            rv = TclXPCOM_GetIdentifierInfoFromClass(interp, cinfo, objv[3], INTERFACEINFO_METHOD, &interfaceinfo, &idinfo);
            if (rv != TCL_OK)
            {
                return rv;
            }
            
            Tcl_SetObjResult(interp, TclXPCOM_GetReturnValueType(interfaceinfo, idinfo));
            return TCL_OK;
            break;

        case XPCOM_ARGS:
            if (objc != 4)
            {
                Tcl_WrongNumArgs(interp, 2, objv, "interfaces method");
                return TCL_ERROR;
            }

            rv = GetClassInfoFromInterfaceList(interp, objv[2], FORCE_NOTSCRIPTABLE, &cinfo);
            if (rv != TCL_OK)
            {
                return rv;
            }

            rv = TclXPCOM_GetIdentifierInfoFromClass(interp, cinfo, objv[3], INTERFACEINFO_METHOD, &interfaceinfo, &idinfo);
            if (rv != TCL_OK)
            {
                return rv;
            }
            
            Tcl_SetObjResult(interp, TclXPCOM_ListMethodArguments(interfaceinfo, idinfo->indices.methodindex));
            return TCL_OK;
            break;

        case XPCOM_CONSTANTS:
            if (objc != 3)
            {
                Tcl_WrongNumArgs(interp, 2, objv, "interface");
                return TCL_ERROR;
            }

            rv = GetInterfaceInfoFromObj(interp, objv[2], &interfaceinfo);
            if (rv != TCL_OK)
            {
                return rv;
            }

            Tcl_SetObjResult(interp, TclXPCOM_ListInterfaceConstants(interfaceinfo));
            NS_RELEASE(interfaceinfo);
            return TCL_OK;
            break;

        case XPCOM_ATTRIBUTES:
            if (objc != 3)
            {
                Tcl_WrongNumArgs(interp, 2, objv, "interfaces");
                return TCL_ERROR;
            }

            rv = GetClassInfoFromInterfaceList(interp, objv[2], FORCE_NOTSCRIPTABLE, &cinfo);
            if (rv != TCL_OK)
            {
                return rv;
            }

            Tcl_SetObjResult(interp, TclXPCOM_ListClassAttributes(cinfo));
            return TCL_OK;
            break;

        case XPCOM_METHODS:
            if (objc != 3)
            {
                Tcl_WrongNumArgs(interp, 2, objv, "interfaces");
                return TCL_ERROR;
            }

            rv = GetClassInfoFromInterfaceList(interp, objv[2], FORCE_NOTSCRIPTABLE, &cinfo);
            if (rv != TCL_OK)
            {
                return rv;
            }

            Tcl_SetObjResult(interp, TclXPCOM_ListClassMethods(cinfo));
            return TCL_OK;
            break;

        }

    return TCL_OK;
}


int
TclXPCOM_ThisObjCmd(
    ClientData     clientData,
    Tcl_Interp    *interp,    
    int            objc,      
    Tcl_Obj *CONST objv[]     
)
{
    nsISupports      *isupports;
    nsIInterfaceInfo *interfaceinfo;

    if (objc != 1)
    {
        Tcl_WrongNumArgs(interp, 1, objv, NULL);
        return TCL_ERROR;
    }
    
    TclXPCOM_GetCurrentComponentContext(&interfaceinfo, &isupports);
    if (isupports)
    {
        Tcl_SetObjResult(interp, TclXPCOM_NewISupportsObj(isupports, interfaceinfo));
        return TCL_OK;
    } else
    {
        Tcl_ResetResult(interp);
        Tcl_AppendResult(interp, "not in a component context", NULL);
        return TCL_ERROR;
    }
}


int
TclXPCOM_ConstantObjCmd(
    ClientData     clientData,
    Tcl_Interp    *interp,    
    int            objc,      
    Tcl_Obj *CONST objv[]     
)
{
    int rv;
    Tcl_Obj *result;
    nsIInterfaceInfo *interfaceinfo;

    if (objc != 3)
    {
        Tcl_WrongNumArgs(interp, 1, objv, "interface constant");
        return TCL_ERROR;
    }
    
    rv = GetInterfaceInfoFromObj(interp, objv[1], &interfaceinfo);
    if (rv != TCL_OK)
    {
        return rv;
    }
    
    rv = TclXPCOM_GetConstant(interp, interfaceinfo, objv[2], &result);
    
    if (rv == TCL_OK)
    {
        Tcl_SetObjResult(interp, result);
    }
    
    NS_RELEASE(interfaceinfo);
    return rv;
}


int
TclXPCOM_NullObjCmd(
    ClientData     clientData,
    Tcl_Interp    *interp,    
    int            objc,      
    Tcl_Obj *CONST objv[]     
)
{
    if (objc != 1)
    {
        Tcl_WrongNumArgs(interp, 1, objv, NULL);
        return TCL_ERROR;
    }
    
    Tcl_SetObjResult(interp, TclXPCOM_NewPointerObj(NULL));
    return TCL_OK;
}


int
TclXPCOM_IsNullObjCmd(
    ClientData     clientData,
    Tcl_Interp    *interp,    
    int            objc,      
    Tcl_Obj *CONST objv[]     
)
{
    if (objc != 2)
    {
        Tcl_WrongNumArgs(interp, 1, objv, "pointer");
        return TCL_ERROR;
    }
    
    Tcl_SetObjResult(interp, Tcl_NewBooleanObj(TclXPCOM_IsNULL(objv[1])));
    return TCL_OK;
}


int
TclXPCOM_PointerObjCmd(
    ClientData     clientData,
    Tcl_Interp    *interp,    
    int            objc,      
    Tcl_Obj *CONST objv[]     
)
{
    void *pointerVal;

    if (objc != 2)
    {
        Tcl_WrongNumArgs(interp, 1, objv, "address");
        return TCL_ERROR;
    }
    
    if (sscanf(Tcl_GetString(objv[1]), "0x%p", &pointerVal) == 1)
    {
        Tcl_SetObjResult(interp, TclXPCOM_NewPointerObj(pointerVal));
        return TCL_OK;
    } else
    {
        Tcl_ResetResult(interp);
        Tcl_AppendResult(interp, "\"", Tcl_GetString(objv[1]), "\" is not a valid pointer address", NULL);
        return TCL_ERROR;
    }
}


int
TclXPCOM_AddressObjCmd(
    ClientData     clientData,
    Tcl_Interp    *interp,    
    int            objc,      
    Tcl_Obj *CONST objv[]     
)
{
    int rv;
    void *pointerVal;
    char str[64];

    if (objc != 2)
    {
        Tcl_WrongNumArgs(interp, 1, objv, "pointer");
        return TCL_ERROR;
    }
    
    rv = TclXPCOM_GetPointerFromObj(interp, objv[1], &pointerVal);
    if (rv != TCL_OK)
    {
        return rv;
    }
    
    sprintf(str, "0x%p", pointerVal);
    Tcl_SetObjResult(interp, Tcl_NewStringObj(str, -1));
    return TCL_OK;
}


int
TclXPCOM_FromStringObjCmd(
    ClientData     clientData,
    Tcl_Interp    *interp,    
    int            objc,      
    Tcl_Obj *CONST objv[]     
)
{
    int rv;

    if (objc != 2)
    {
        Tcl_WrongNumArgs(interp, 1, objv, "string");
        return TCL_ERROR;
    }
    
    rv = Tcl_ConvertToType(interp, objv[1], &ISupportsType);
    
    if (rv != TCL_OK)
    {
        return rv;
    }
    
    Tcl_SetObjResult(interp, objv[1]);
    return TCL_OK;
}


int
TclXPCOM_SetReturnCodeObjCmd(
    ClientData     clientData,
    Tcl_Interp    *interp,    
    int            objc,      
    Tcl_Obj *CONST objv[]     
)
{
    int rv;
    long longVal;

    if (objc != 2)
    {
        Tcl_WrongNumArgs(interp, 1, objv, "code");
        return TCL_ERROR;
    }
    
    rv = Tcl_GetLongFromObj(interp, objv[1], &longVal);
    if (rv != TCL_OK)
    {
        return rv;
    }
    
    if (!TclXPCOM_SetReturnCode((nsresult)longVal))
    {
        Tcl_ResetResult(interp);
        Tcl_AppendResult(interp, "not in a component context", NULL);
        return TCL_ERROR;
    }
    
    return TCL_OK;
}


int
TclXPCOM_IdObjCmd(
    ClientData     clientData,
    Tcl_Interp    *interp,    
    int            objc,      
    Tcl_Obj *CONST objv[]     
)
{
    int rv;
    nsIID *iid;
    char *str;

    if (objc != 2)
    {
        Tcl_WrongNumArgs(interp, 1, objv, "name");
        return TCL_ERROR;
    }
    
    rv = TclXPCOM_GetNsIDFromObj(interp, objv[1], &iid);
    if (rv != TCL_OK)
    {
        return rv;
    }
    
    str = ((nsID *)iid)->ToString();
    Tcl_SetObjResult(interp, Tcl_NewStringObj(str, -1));
    memmgr->Free(str);
    return TCL_OK;
}


#define NUM_COMMANDS  12

static struct
{
    char *command;
    Tcl_ObjCmdProc *cmdproc;
    ClientData clientdata;

} cmdtable[NUM_COMMANDS] =
{
    {"xpcom::invoke",        TclXPCOM_InvokeObjCmd,        (ClientData)1},
    {"xpcom::wrap",          TclXPCOM_WrapObjCmd,          (ClientData)NULL},
    {"xpcom::this",          TclXPCOM_ThisObjCmd,          (ClientData)NULL},
    {"xpcom::constant",      TclXPCOM_ConstantObjCmd,      (ClientData)NULL},
    {"xpcom::info",          TclXPCOM_InfoObjCmd,          (ClientData)NULL},
    {"xpcom::null",          TclXPCOM_NullObjCmd,          (ClientData)NULL},
    {"xpcom::isnull",        TclXPCOM_IsNullObjCmd,        (ClientData)NULL},
    {"xpcom::pointer",       TclXPCOM_PointerObjCmd,       (ClientData)NULL},
    {"xpcom::address",       TclXPCOM_AddressObjCmd,       (ClientData)NULL},
    {"xpcom::fromstring",    TclXPCOM_FromStringObjCmd,    (ClientData)NULL},
    {"xpcom::setReturnCode", TclXPCOM_SetReturnCodeObjCmd, (ClientData)NULL},
    {"xpcom::id",            TclXPCOM_IdObjCmd,            (ClientData)NULL}
};


void
TclXPCOM_RegisterCommands(
    Tcl_Interp *interp 
)
{
    int i;

    for (i = 0; i < NUM_COMMANDS; i++)
    {
        Tcl_CreateObjCommand(interp, cmdtable[i].command, cmdtable[i].cmdproc, cmdtable[i].clientdata, NULL);
    }
}

---