---

TclXPCOMInvoke.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"
#include "nsString.h"


#define INVOKE_BUFFERSIZE   16


void
PrepareVariant(
    nsXPTCVariant  *param,    
    nsXPTParamInfo *paraminfo 
)
{
    NS_PRECONDITION(param, "null pointer");
    NS_PRECONDITION(paraminfo, "null pointer");

    param->type = paraminfo->GetType();
    param->ClearFlags();

    if (paraminfo->IsOut())
    {
        param->SetPtrIsData();
        param->ptr = &param->val.p;
    } else
    {
        param->ptr = NULL;
    }
    
    if (param->type.IsPointer())
    {
        switch (param->type.TagPart())
        {
            case nsXPTType::T_ASTRING:
            case nsXPTType::T_DOMSTRING:
                param->val.p = new nsString();
                break;

            case nsXPTType::T_CSTRING:
            case nsXPTType::T_UTF8STRING:
                param->val.p = new nsCString();
                break;

            default:
                param->val.p = NULL;
                break;
        }
    }
}


int
TclXPCOM_Invoke(
    Tcl_Interp       *interp,       
    Tcl_Obj          *CONST objv[], 
    nsISupports      *isupports,    
    nsIInterfaceInfo *interfaceinfo,
    PRUint16          methodindex   
)
{
    char str[128];

    int rv;
    nsresult res;

    Tcl_Obj *param;

    nsXPTCVariant  *variants;
    void           **params;

    nsXPTCVariant stackedvariants[INVOKE_BUFFERSIZE];
    void          *stackedparams[INVOKE_BUFFERSIZE];

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

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

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

    if (paramcount > INVOKE_BUFFERSIZE)
    {
        variants = (nsXPTCVariant *)memmgr->Alloc(sizeof(nsXPTCVariant) * paramcount);
        params =           (void **)memmgr->Alloc(sizeof(void *) * paramcount);
    } else
    {
        variants = stackedvariants;
        params   = stackedparams;
    }

    for (i = 0; i < paramcount; i++)
    {
        PrepareVariant(&variants[i], &paraminfos[i]);
        params[i] = &variants[i].val;
    }
    
    /*
    TCL Calling C++
    1) write in and in/out parameters
    2) if writing fails (bad tcl script inputs), cleanup in and in/out parameters and return code
    3) call C++
    4) if failed, free in and in/out parameters
    5) read in/out and out parameters
    6) free in, in/out, and out (not shared) parameters
    7) return code
    */

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

        j = (tclparams[i] & PARAM_INDEX_MASK);

        if (paraminfos[i].IsIn() && !paraminfos[i].IsDipper())
        {
            if (paraminfos[i].IsOut())
            {
                param = Tcl_ObjGetVar2(interp, objv[j], NULL, 0);
                if (param == NULL)
                {
                    Tcl_ResetResult(interp);
                    Tcl_AppendResult(interp, "in/out variable \"", Tcl_GetString(objv[j]), "\" must be set", NULL);
                    rv = TCL_ERROR;
                    goto done;
                }
            } else
            {
                param = objv[j];
            }

            rv = Tcl2Native(interp, param, params, params[i], &variants[i].type, tclparams[i] & PARAM_IS_SHARED_IN, interfaceinfo, methodindex, &paraminfos[i]);

            //2) if writing fails (bad tcl script inputs), cleanup in and in/out parameters and return code
            if (rv != TCL_OK)
            {
                sprintf(str, "\nwhile writing in parameter #%d", j);
                Tcl_AddObjErrorInfo(interp, str, -1);
                goto done;
            }
        }
    }

    //3) call C++
    res = XPTC_InvokeByIndex(isupports, (PRUint32)methodindex, (PRUint32)paramcount, variants);

    Tcl_SetVar2Ex(interp, TCLXPCOM_LASTRESULTVARNAME, NULL, Tcl_NewLongObj((long)res), TCL_GLOBAL_ONLY);

    //4) if failed, free in and in/out parameters
    if (NS_SUCCEEDED(res))
    {
        rv = TCL_OK;
    } else
    {
        TclXPCOM_SetError(interp, res);
        rv = TCL_ERROR;
        goto done;
    }
    
    //5) read in/out and out parameters
    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())
        {
            res = Native2Tcl(params, params[i], &variants[i].type, interfaceinfo, methodindex, &paraminfos[i], &param);

            if (NS_FAILED(res))
            {
                TclXPCOM_SetError(interp, res);

                if (paraminfos[i].IsRetval())
                {
                    sprintf(str, "\nwhile reading return parameter");
                } else
                {
                    sprintf(str, "\nwhile reading out parameter #%d", j);
                }
                Tcl_AddObjErrorInfo(interp, str, -1);
                rv = TCL_ERROR;
                goto done;
            }

            if (paraminfos[i].IsRetval())
            {
                Tcl_SetObjResult(interp, param);
            } else
            {
                Tcl_ObjSetVar2(interp, objv[j], NULL, param, 0);
            }
        }
    }

done:
    //6) free in, in/out, and out (but not shared) parameters
    for (i = 0; i < paramcount; i++)
    {
        CleanupParam(params, params[i], &variants[i].type, interfaceinfo, methodindex, &paraminfos[i]);
    }
    
    if (paramcount > INVOKE_BUFFERSIZE)
    {
        memmgr->Free(variants);
        memmgr->Free(params);
    }

    return rv;
}

---