/* 

 * tclTestProcBodyObj.c --

 *

 *	Implements the "procbodytest" package, which contains commands

 *	to test creation of Tcl procedures whose body argument is a

 *	Tcl_Obj of type "procbody" rather than a string.

 *

 * Copyright (c) 1998 by Scriptics Corporation.

 *

 * See the file "license.terms" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * RCS: @(#) $Id: tclTestProcBodyObj.c,v 1.2 1998/11/10 06:54:44 jingham Exp $

 */

#include "tclInt.h"

/*

 * name and version of this package

 */

static char packageName[] = "procbodytest";

static char packageVersion[] = "1.0";

/*

 * Name of the commands exported by this package

 */

static char procCommand[] = "proc";

/*

 * this struct describes an entry in the table of command names and command

 * procs

 */

typedef struct CmdTable

{

    char *cmdName;		/* command name */

    Tcl_ObjCmdProc *proc;	/* command proc */

    int exportIt;		/* if 1, export the command */

} CmdTable;

/*

 * Declarations for functions defined in this file.

 */

static int	ProcBodyTestProcObjCmd _ANSI_ARGS_((ClientData dummy,

			Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]));

static int	ProcBodyTestInitInternal _ANSI_ARGS_((Tcl_Interp *interp,

			int isSafe));

static int	RegisterCommand _ANSI_ARGS_((Tcl_Interp* interp,

			char *namespace, CONST CmdTable *cmdTablePtr));

int             Procbodytest_Init _ANSI_ARGS_((Tcl_Interp * interp));

int             Procbodytest_SafeInit _ANSI_ARGS_((Tcl_Interp * interp));

/*

 * List of commands to create when the package is loaded; must go after the

 * declarations of the enable command procedure.

 */

static CONST CmdTable commands[] =

{

    { procCommand,	ProcBodyTestProcObjCmd,	1 },

    { 0, 0, 0 }

};

static CONST CmdTable safeCommands[] =

{

    { procCommand,	ProcBodyTestProcObjCmd,	1 },

    { 0, 0, 0 }

};

/*

 *----------------------------------------------------------------------

 *

 * Procbodytest_Init --

 *

 *  This procedure initializes the "procbodytest" package.

 *

 * Results:

 *  A standard Tcl result.

 *

 * Side effects:

 *  None.

 *

 *----------------------------------------------------------------------

 */

int

Procbodytest_Init(interp)

    Tcl_Interp *interp;		/* the Tcl interpreter for which the package

                                 * is initialized */

{

    return ProcBodyTestInitInternal(interp, 0);

}

/*

 *----------------------------------------------------------------------

 *

 * Procbodytest_SafeInit --

 *

 *  This procedure initializes the "procbodytest" package.

 *

 * Results:

 *  A standard Tcl result.

 *

 * Side effects:

 *  None.

 *

 *----------------------------------------------------------------------

 */

int

Procbodytest_SafeInit(interp)

    Tcl_Interp *interp;		/* the Tcl interpreter for which the package

                                 * is initialized */

{

    return ProcBodyTestInitInternal(interp, 1);

}

/*

 *----------------------------------------------------------------------

 *

 * RegisterCommand --

 *

 *  This procedure registers a command in the context of the given namespace.

 *

 * Results:

 *  A standard Tcl result.

 *

 * Side effects:

 *  None.

 *

 *----------------------------------------------------------------------

 */

static int RegisterCommand(interp, namespace, cmdTablePtr)

    Tcl_Interp* interp;			/* the Tcl interpreter for which the

                                         * operation is performed */

    char *namespace;			/* the namespace in which the command

                                         * is registered */

    CONST CmdTable *cmdTablePtr;	/* the command to register */

{

    char buf[128];

    if (cmdTablePtr->exportIt) {

        sprintf(buf, "namespace eval %s { namespace export %s }",

                namespace, cmdTablePtr->cmdName);

        if (Tcl_Eval(interp, buf) != TCL_OK)

            return TCL_ERROR;

    }

    sprintf(buf, "%s::%s", namespace, cmdTablePtr->cmdName);

    Tcl_CreateObjCommand(interp, buf, cmdTablePtr->proc, 0, 0);

    return TCL_OK;

}

/*

 *----------------------------------------------------------------------

 *

 * ProcBodyTestInitInternal --

 *

 *  This procedure initializes the Loader package.

 *  The isSafe flag is 1 if the interpreter is safe, 0 otherwise.

 *

 * Results:

 *  A standard Tcl result.

 *

 * Side effects:

 *  None.

 *

 *----------------------------------------------------------------------

 */

static int

ProcBodyTestInitInternal(interp, isSafe)

    Tcl_Interp *interp;		/* the Tcl interpreter for which the package

                                 * is initialized */

    int isSafe;			/* 1 if this is a safe interpreter */

{

    CONST CmdTable *cmdTablePtr;

    cmdTablePtr = (isSafe) ? &safeCommands[0] : &commands[0];

    for ( ; cmdTablePtr->cmdName ; cmdTablePtr++) {

        if (RegisterCommand(interp, packageName, cmdTablePtr) != TCL_OK) {

            return TCL_ERROR;

        }

    }

    return Tcl_PkgProvide(interp, packageName, packageVersion);

}

/*

 *----------------------------------------------------------------------

 *

 * ProcBodyTestProcObjCmd --

 *

 *  Implements the "procbodytest::proc" command. Here is the command

 *  description:

 *	procbodytest::proc newName argList bodyName

 *  Looks up a procedure called $bodyName and, if the procedure exists,

 *  constructs a Tcl_Obj of type "procbody" and calls Tcl_ProcObjCmd.

 *  Arguments:

 *    newName		the name of the procedure to be created

 *    argList		the argument list for the procedure

 *    bodyName		the name of an existing procedure from which the

 *			body is to be copied.

 *  This command can be used to trigger the branches in Tcl_ProcObjCmd that

 *  construct a proc from a "procbody", for example:

 *	proc a {x} {return $x}

 *	a 123

 *	procbodytest::proc b {x} a

 *  Note the call to "a 123", which is necessary so that the Proc pointer

 *  for "a" is filled in by the internal compiler; this is a hack.

 *

 * Results:

 *  Returns a standard Tcl code.

 *

 * Side effects:

 *  A new procedure is created.

 *  Leaves an error message in the interp's result on error.

 *

 *----------------------------------------------------------------------

 */

static int

ProcBodyTestProcObjCmd (dummy, interp, objc, objv)

    ClientData dummy;		/* context; not used */

    Tcl_Interp *interp;		/* the current interpreter */

    int objc;			/* argument count */

    Tcl_Obj *CONST objv[];	/* arguments */

{

    char *fullName;

    Tcl_Command procCmd;

    Command *cmdPtr;

    Proc *procPtr = (Proc *) NULL;

    Tcl_Obj *bodyObjPtr;

    Tcl_Obj *myobjv[5];

    int result;

    if (objc != 4) {

	Tcl_WrongNumArgs(interp, 1, objv, "newName argsList bodyName");

	return TCL_ERROR;

    }

    /*

     * Find the Command pointer to this procedure

     */

    fullName = Tcl_GetStringFromObj(objv[3], (int *) NULL);

    procCmd = Tcl_FindCommand(interp, fullName, (Tcl_Namespace *) NULL,

            TCL_LEAVE_ERR_MSG);

    if (procCmd == NULL) {

        return TCL_ERROR;

    }

    cmdPtr = (Command *) procCmd;

    /*

     * check that this is a procedure and not a builtin command:

     * If a procedure, cmdPtr->objProc is either 0 or TclObjInterpProc,

     * and cmdPtr->proc is either 0 or TclProcInterpProc.

     * Also, the compile proc should be 0, but we don't check for that.

     */

    if (((cmdPtr->objProc != NULL)

            && (cmdPtr->objProc != TclGetObjInterpProc()))

            || ((cmdPtr->proc != NULL)

                    && (cmdPtr->proc != TclGetInterpProc()))) {

        Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),

		"command \"", fullName,

		"\" is not a Tcl procedure", (char *) NULL);

        return TCL_ERROR;

    }

    /*

     * it is a Tcl procedure: the client data is the Proc structure

     */

    if (cmdPtr->objProc != NULL) {

        procPtr = (Proc *) cmdPtr->objClientData;

    } else if (cmdPtr->proc != NULL) {

        procPtr = (Proc *) cmdPtr->clientData;

    }

    if (procPtr == NULL) {

        Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),

		"procedure \"", fullName,

		"\" does not have a Proc struct!", (char *) NULL);

        return TCL_ERROR;

    }

    /*

     * create a new object, initialize our argument vector, call into Tcl

     */

    bodyObjPtr = TclNewProcBodyObj(procPtr);

    if (bodyObjPtr == NULL) {

        Tcl_AppendStringsToObj(Tcl_GetObjResult(interp),

		"failed to create a procbody object for procedure \"",

                fullName, "\"", (char *) NULL);

        return TCL_ERROR;

    }

    Tcl_IncrRefCount(bodyObjPtr);

    myobjv[0] = objv[0];

    myobjv[1] = objv[1];

    myobjv[2] = objv[2];

    myobjv[3] = bodyObjPtr;

    myobjv[4] = (Tcl_Obj *) NULL;

    result = Tcl_ProcObjCmd((ClientData) NULL, interp, objc, myobjv);

    Tcl_DecrRefCount(bodyObjPtr);

    return result;

}