---

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


#define STUBS_BUFFERSIZE        16


typedef struct CurrentStubInfo {
    nsISupports       *currentstub;  
    nsIInterfaceInfo  *interfaceinfo;
    int                nestlevel;    
    nsresult           returnCode;   
} CurrentStubInfo;

static Tcl_ThreadDataKey currentStubKey;


void
TclXPCOM_GetCurrentComponentContext(
    nsIInterfaceInfo **interfaceinfo,
    nsISupports      **isupports     
)
{
    NS_PRECONDITION(interfaceinfo, "null pointer");
    NS_PRECONDITION(isupports, "null pointer");

    CurrentStubInfo *stubinfo;
    stubinfo = (CurrentStubInfo *)Tcl_GetThreadData(&currentStubKey, sizeof(CurrentStubInfo));
    *isupports     = stubinfo->currentstub;
    *interfaceinfo = stubinfo->interfaceinfo;
}


int
TclXPCOM_SetReturnCode(
    nsresult res 
)
{
    CurrentStubInfo *stubinfo;

    stubinfo = (CurrentStubInfo *)Tcl_GetThreadData(&currentStubKey, sizeof(CurrentStubInfo));

    if (stubinfo->currentstub)
    {
        stubinfo->returnCode = res;
        return 1;
    } else
    {
        return 0;
    }
}


void
CleanupOutParameters(
    void             **params,      
    nsXPTParamInfo   *paraminfos,   
    PRUint8           paramcount,   
    nsIInterfaceInfo *interfaceinfo,
    PRUint16          methodindex   
)
{
    PRUint8 i;
    nsXPTType type;

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

    for (i = 0; i < paramcount; i++)
    {
        if (paraminfos[i].IsOut())
        {
            type = paraminfos[i].GetType();
            CleanupParam(params, params[i], &type, interfaceinfo, methodindex, &paraminfos[i]);
            if (type.IsPointer())
            {
                *(void **)params[i] = NULL;
            }
        }
    }
}


Tcl_Obj *
NewOutParam(
    int stubid,    
    int paramindex 
)
{
    char str[128];
    sprintf(str, "::xpcom::outparams(%u-%u)", stubid, paramindex);
    return Tcl_NewStringObj(str, -1);
}


void
CleanupTclOutVariables(
    int             stubid,    
    Tcl_Interp     *interp,    
    nsXPTParamInfo *paraminfos,
    PRUint8         paramcount,
    PRUint16       *tclparams  
)
{
    PRUint8 i;
    Tcl_Obj *paramname;

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

    for (i = 0; i < paramcount; i++)
    {
        if (!(tclparams[i] & PARAM_IS_SKIPPED)
            && (paraminfos[i].IsOut() || paraminfos[i].IsDipper())
            && !(paraminfos[i].IsRetval()))
        {
            paramname = NewOutParam(stubid, i);
            Tcl_UnsetVar2(interp, Tcl_GetString(paramname), NULL, TCL_GLOBAL_ONLY);
            Tcl_DecrRefCount(paramname);
        }
    }
}


void
AddObjErrorInfoForBinding(
    Tcl_Interp       *interp,       
    nsISupports      *isupports,    
    nsIInterfaceInfo *interfaceinfo,
    PRUint16          methodindex,  
    Tcl_Obj          *script        
)
{
    const char *name;
    const nsXPTMethodInfo *methodinfo;
    Tcl_Obj *isupportsobj;

    NS_PRECONDITION(interp, "null pointer");
    NS_PRECONDITION(isupports, "null pointer");
    NS_PRECONDITION(interfaceinfo, "null pointer");
    NS_PRECONDITION(script, "null pointer");

    Tcl_AddObjErrorInfo(interp, "\nwhile executing binding:\n\"", -1);
    Tcl_AddObjErrorInfo(interp, Tcl_GetString(script), -1);
    Tcl_AddObjErrorInfo(interp, "\"\nfor interface ", -1);
    
    interfaceinfo->GetMethodInfo(methodindex, &methodinfo);
    
    if (methodinfo->IsGetter())
    {
        Tcl_AddObjErrorInfo(interp, "attribute getter \"", -1);
    } else if (methodinfo->IsSetter())
    {
        Tcl_AddObjErrorInfo(interp, "attribute setter \"", -1);
    } else
    {
        Tcl_AddObjErrorInfo(interp, "method \"", -1);
    }
    
    interfaceinfo->GetNameShared(&name);
    Tcl_AddObjErrorInfo(interp, name, -1);
    Tcl_AddObjErrorInfo(interp, "::", -1);
    name = methodinfo->GetName();
    Tcl_AddObjErrorInfo(interp, name, -1);
    Tcl_AddObjErrorInfo(interp, "\"", -1);
    
    Tcl_AddObjErrorInfo(interp, "\nin component context \"", -1);
    
    isupportsobj = TclXPCOM_NewISupportsObj(isupports, interfaceinfo);
    Tcl_AddObjErrorInfo(interp, Tcl_GetString(isupportsobj), -1);
    Tcl_DecrRefCount(isupportsobj);
    
    Tcl_AddObjErrorInfo(interp, "\"", -1);
}


nsresult
TclXPCOM_CallMethod(
    Tcl_Interp        *interp,       
    nsXPTCMiniVariant *variants,     
    nsISupports       *isupports,    
    nsIInterfaceInfo  *interfaceinfo,
    PRUint16           methodindex,  
    Tcl_Obj           *script        
)
{
    int rv;
    nsresult res;
    nsXPTType type;
    char str[128];
    
    Tcl_SavedResult savedresult;
    Tcl_Obj  *errorcode, *errorinfo;
    Tcl_Obj  *param, *paramname;
    void    **params;
    void     *stackedparams[STUBS_BUFFERSIZE];

    PRUint16 j, *tclparams;
    PRUint8  i, paramcount;
    nsXPTParamInfo *paraminfos;
    MethodInfo *minfo;

    int bgerror;
    int stubid;
    CurrentStubInfo *stubinfo, savedstubinfo;

    NS_PRECONDITION(interp, "null pointer");
    NS_PRECONDITION(variants, "null pointer");
    NS_PRECONDITION(isupports, "null pointer");
    NS_PRECONDITION(interfaceinfo, "null pointer");
    NS_PRECONDITION(script, "null pointer");

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

    if (paramcount > STUBS_BUFFERSIZE)
    {
        params = (void **)memmgr->Alloc(sizeof(void *) * paramcount);
    } else
    {
        params = stackedparams;
    }


    Tcl_Preserve(interp);
    Tcl_SaveResult(interp, &savedresult);
    errorcode = Tcl_GetVar2Ex(interp, "errorCode", NULL, TCL_GLOBAL_ONLY);
    errorinfo = Tcl_GetVar2Ex(interp, "errorInfo", NULL, TCL_GLOBAL_ONLY);

    if (errorcode)
    {
        Tcl_IncrRefCount(errorcode);
    }

    if (errorinfo)
    {
        Tcl_IncrRefCount(errorinfo);
    }

    script = Tcl_DuplicateObj(script);
    Tcl_IncrRefCount(script);

    stubinfo = (CurrentStubInfo *)Tcl_GetThreadData(&currentStubKey, sizeof(CurrentStubInfo));
    savedstubinfo = *stubinfo;

    stubinfo->currentstub   = isupports;
    stubinfo->interfaceinfo = interfaceinfo;
    stubinfo->returnCode    = NS_OK;
    stubinfo->nestlevel++;

    stubid = stubinfo->nestlevel;

    /*  
    C++ Calling TCL
    0) make sure no out or in/out parameter pointers are NULL (calling function is crappy)
    1) read in and in/out parameters
    2) free any in/out parameters
    3) write NULL to in/out and out parameters
    --- thread check,  if on different thread,  post an event & wait for return
    4) eval tcl
    5) if ok, write in/out and out parameters (shared is weird)
    6) if writing fails (bad tcl script returns), cleanup in/out and out parameters and write NULL to them
    7) return code
    */

    bgerror = 0;

    for (i = 0; i < paramcount; i++)
    {
        if (paraminfos[i].IsOut())
        {
            params[i] = variants[i].val.p;
            //0) make sure no out or in/out parameter pointers are NULL (calling function is crappy)
            if (!params[i])
            {
                // return error,  calling function is crap
                res = NS_ERROR_NULL_POINTER;
                goto done;
            }

            if (!paraminfos[i].IsIn() && paraminfos[i].GetType().IsPointer())
            {
                *(void **)params[i] = NULL;
            }
        } else
        {
            params[i] = &variants[i];
        }
    }

    //1) read in and in/out parameters
    for (i = 0; i < paramcount; i++)
    {
        if ((tclparams[i] & PARAM_IS_SKIPPED) || (tclparams[i] & PARAM_IS_RETVAL))
        {
            continue;
        }

        j = (tclparams[i] & PARAM_INDEX_MASK);
        
        if (paraminfos[i].IsIn() && !paraminfos[i].IsDipper())
        {
            // read parameter
            type = paraminfos[i].GetType();

            res = Native2Tcl(params, params[i], (nsXPTType *)&paraminfos[i].type, interfaceinfo, methodindex, &paraminfos[i], &param);
            if (NS_FAILED(res))
            {
                goto done;
            }
            
            // append parameter to arg list or append name of set variable
            if (paraminfos[i].IsOut())
            {
                // create a variable
                paramname = NewOutParam(stubid, i);
                Tcl_ObjSetVar2(interp, paramname, NULL, param, TCL_GLOBAL_ONLY);
                param = paramname;
            }
        } else
        {
            param = NewOutParam(stubid, i);
            Tcl_UnsetVar2(interp, Tcl_GetString(param), NULL, TCL_GLOBAL_ONLY);
        }

        rv = Tcl_ListObjAppendElement(NULL, script, param);
        NS_ASSERTION((rv == TCL_OK), "script is not a valid list");
    }

    //2) free any in/out parameters
    //3) write NULL to in/out and out parameters
    CleanupOutParameters(params, paraminfos, paramcount, interfaceinfo, methodindex);

    //4) eval tcl
    rv = Tcl_EvalObjEx(interp, script, TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL);

    if (rv == TCL_OK)
    {
        res = stubinfo->returnCode;
    } else
    {
        if (!TclXPCOM_GetErrorCode(interp, &res))
        {
            res = NS_ERROR_FAILURE;
            bgerror = 1;
        }
    }

    if (NS_FAILED(res))
    {
        goto done;
    }
    
    //5) if ok, write in/out and out parameters (shared is weird)
    for (i = 0; i < paramcount; i++)
    {
        if (tclparams[i] & PARAM_IS_SKIPPED)
        {
            continue;
        }

        j = (tclparams[i] & PARAM_INDEX_MASK);
        
        if (paraminfos[i].IsOut() || paraminfos[i].IsDipper())
        {
            if (paraminfos[i].IsRetval())
            {
                param = Tcl_GetObjResult(interp);
            } else
            {
                paramname = NewOutParam(stubid, i);
                param = Tcl_ObjGetVar2(interp, paramname, NULL, TCL_GLOBAL_ONLY);
                Tcl_DecrRefCount(paramname);
                if (!param)
                {
                    // error if param is null
                    Tcl_ResetResult(interp);
                    Tcl_AppendResult(interp, "out parameter was not set", NULL);
                    rv = TCL_ERROR;
                }
            }
            
            if (rv == TCL_OK)
            {
                type = paraminfos[i].GetType();
                rv = Tcl2Native(interp, param, params, params[i], &type, tclparams[i] & PARAM_IS_SHARED_OUT, interfaceinfo, methodindex, &paraminfos[i]);
            }

            // if error,  while 'writing parameter #'
            if (rv != TCL_OK)
            {
                //6) if writing fails (bad tcl script returns), cleanup in/out and out parameters and write NULL to them
                if (paraminfos[i].IsRetval())
                {
                    sprintf(str, "\nwhile writing return parameter");
                } else
                {
                    sprintf(str, "\nwhile writing out parameter #%d", j);
                }
                Tcl_AddObjErrorInfo(interp, str, -1);

                CleanupOutParameters(params, paraminfos, paramcount, interfaceinfo, methodindex);
                res = NS_ERROR_FAILURE;
                bgerror = 1;
                goto done;
            }
        }
    }

done:
    
    CleanupTclOutVariables(stubid, interp, paraminfos, paramcount, tclparams);

    if (bgerror)
    {
        AddObjErrorInfoForBinding(interp, isupports, interfaceinfo, methodindex, script);
        TclXPCOM_BackgroundError(interp);
    }

    if (paramcount > STUBS_BUFFERSIZE)
    {
        memmgr->Free(params);
    }

    *stubinfo = savedstubinfo;
    Tcl_DecrRefCount(script);

    if (errorcode)
    {
        Tcl_SetVar2Ex(interp, "errorCode", NULL, errorcode, TCL_GLOBAL_ONLY);
        Tcl_DecrRefCount(errorcode);
    }

    if (errorinfo)
    {
        Tcl_SetVar2Ex(interp, "errorInfo", NULL, errorinfo, TCL_GLOBAL_ONLY);
        Tcl_DecrRefCount(errorinfo);
    }

    Tcl_RestoreResult(interp, &savedresult);
    Tcl_Release(interp);
    return res;
}

---