---

TclXPCOMComponent.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
InterpDeletedCallback(
    ClientData  clientData,
    Tcl_Interp *interp     
)
{
    NS_PRECONDITION(clientData, "null pointer");
    NS_PRECONDITION(interp, "null pointer");

    char str[128];
    sprintf(str, "Interpreter for Component %p has been killed", clientData);
    NS_WARNING(str);
    
    ((TclXPCOMComponent *)clientData)->interp = NULL;
}


TclXPCOMComponent *
NewTclXPCOMComponent(
    Tcl_Interp   *interp, 
    Tcl_ThreadId  thread, 
    ClassInfo    *cinfo   
)
{
    int i;
    TclXPCOMComponent *component;

    NS_PRECONDITION(interp, "null pointer");
    // no precondition on thread
    NS_PRECONDITION(cinfo, "null pointer");

    component = (TclXPCOMComponent *)memmgr->Alloc(sizeof(TclXPCOMComponent));

    component->stubs = (TclXPCOMStub **)memmgr->Alloc(sizeof(TclXPCOMStub *) * cinfo->signature.infocount);

    for (i = 0; i < cinfo->signature.infocount; i++)
    {
        component->stubs[i] = new TclXPCOMStub(cinfo->signature.infolist[i]);
    }

    component->refcount   = 0;
    component->interp     = interp;
    component->thread     = thread;
    component->cinfo      = cinfo;
    component->destructor = NULL;
    component->nesting    = 0;

    for (i = 0; i < cinfo->signature.infocount; i++)
    {
        component->stubs[i]->component = component;
    }

    Tcl_CallWhenDeleted(interp, InterpDeletedCallback, (ClientData)component);

    return component;
}


void
UnsetDestructorBinding(
    TclXPCOMComponent *component 
)
{
    NS_PRECONDITION(component, "null pointer");

    if (component->destructor)
    {
        Tcl_DecrRefCount(component->destructor);
        component->destructor = NULL;
    }
}


void
SetDestructorBinding(
    TclXPCOMComponent *component,
    Tcl_Obj           *script    
)
{
    NS_PRECONDITION(component, "null pointer");
    NS_PRECONDITION(script, "null pointer");

    if (component->destructor)
    {
        UnsetDestructorBinding(component);
    }

    component->destructor = script;
    Tcl_IncrRefCount(component->destructor);
}


void
FreeTclXPCOMComponent(
    TclXPCOMComponent *component 
)
{
    int i;

    NS_PRECONDITION(component, "null pointer");

    if (component->interp)
    {
        Tcl_DontCallWhenDeleted(component->interp, InterpDeletedCallback, (ClientData)component);
    }

    UnsetDestructorBinding(component);

    for (i = 0; i < component->cinfo->signature.infocount; i++)
    {
        delete component->stubs[i];
    }

    memmgr->Free(component->stubs);
}


int
BindScript(
    Tcl_Interp        *interp,    
    TclXPCOMComponent *component, 
    Tcl_Obj           *identifier,
    Tcl_Obj           *script,    
    int                flags      
)
{
    int rv;
    int i;
    int length;

    int index;
    PRUint16 identifiercount;
    PRUint16 methodindex, getterindex, setterindex;

    nsIInterfaceInfo *info;
    IdentifierInfo       *idinfo;
    ClassIdentifierInfo  *identifiers;

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

    if (strlen(Tcl_GetString(identifier)) == 0)
    {
        if (component->destructor)
        {
            Tcl_ResetResult(interp);
            Tcl_AppendResult(interp, "destructor is already bound", NULL);
            return TCL_ERROR;
        }

        SetDestructorBinding(component, script);
        return TCL_OK;
    }

    rv = Tcl_ListObjLength(interp, script, &length);
    if (rv != TCL_OK)
    {
        Tcl_ResetResult(interp);
        Tcl_AppendResult(interp, "binding \"", Tcl_GetString(script), "\" is not a valid list", NULL);
        return TCL_ERROR;
    }

    identifiercount = component->cinfo->attributecount + component->cinfo->methodcount;
    if (identifiercount)
    {
        identifiers = (ClassIdentifierInfo *)memmgr->Alloc(sizeof(ClassIdentifierInfo) * identifiercount + sizeof(char *));
        memcpy(&identifiers[0], &component->cinfo->attributes[0], sizeof(ClassIdentifierInfo) * component->cinfo->attributecount);
        memcpy(&identifiers[component->cinfo->attributecount], &component->cinfo->methods[0], sizeof(ClassIdentifierInfo) * component->cinfo->methodcount);
        identifiers[identifiercount].idinfo.name = NULL;

        rv = Tcl_GetIndexFromObjStruct(interp, identifier, (char **)&identifiers[0].idinfo.name, sizeof(ClassIdentifierInfo), "method or attribute", 0, &index);

        if (rv == TCL_OK)
        {
            idinfo = &identifiers[index].idinfo;
            info = identifiers[index].info;
            rv = TclXPCOM_CheckInterfaceIsReflectable(interp, info, flags);
        }

        if (rv == TCL_OK)
        {
            if ((idinfo->type & INTERFACEINFO_METHOD)
                || (idinfo->type & INTERFACEINFO_GETTER))
            {
                methodindex = idinfo->indices.methodindex;
                getterindex = idinfo->indices.attributeindices.getterindex;
                rv = TclXPCOM_CheckMethodIsReflectable(interp, info, methodindex, flags);
            }
        }

        if (rv == TCL_OK)
        {
            if (idinfo->type & INTERFACEINFO_SETTER)
            {
                setterindex = idinfo->indices.attributeindices.setterindex;
                rv = TclXPCOM_CheckMethodIsReflectable(interp, info, setterindex, flags);
            }
        }

        if (rv == TCL_OK)
        {
            if (idinfo->type & INTERFACEINFO_METHOD)
            {
                for (i = 0; i < component->cinfo->signature.infocount; i++)
                {
                    if (IsInInterface(info, component->cinfo->signature.infolist[i]))
                    {
                        component->stubs[i]->SetBinding(methodindex, script);
                    }
                }
            } else
            {
                for (i = 0; i < component->cinfo->signature.infocount; i++)
                {
                    if (IsInInterface(info, component->cinfo->signature.infolist[i]))
                    {
                        if (idinfo->type & INTERFACEINFO_GETTER)
                        {
                            component->stubs[i]->SetBinding(getterindex, script);
                        }

                        if (idinfo->type & INTERFACEINFO_SETTER)
                        {
                            component->stubs[i]->SetBinding(setterindex, script);
                        }
                    }
                }
            }
        }

        memmgr->Free(identifiers);
        return rv;
    } else
    {
        Tcl_AppendResult(interp, "no methods or attributes in class", NULL);
        return TCL_ERROR;
    }
}

---