Tcl Source Code

 *----------------------------------------------------------------------
 *
 * GetCommandSource --
 *
 *	This function returns a Tcl_Obj with the full source string for the
 *	command. This insures that traces get a correct NUL-terminated command
 *	string.
 *	If parameter 'command' is (char*)-1 it returns a pointer to the command's 
 *	source using TclGetSrcInfoForCmd. As parameter 'numChars' could be used 
 *	an ENSEMBLE_PSEUDO_COMMAND to advise call of the ensemble command.
 *
 *----------------------------------------------------------------------
 */

static Tcl_Obj *
GetCommandSource(
    Interp *iPtr,
    const char *command,
    int numChars,
    int objc,
    Tcl_Obj *const objv[])
{
    if (!command) {
	return Tcl_NewListObj(objc, objv);
    }
    if (command == (char *) -1) {
	command = TclGetSrcInfoForCmd(iPtr, &numChars);
	if (!command) {
	    return Tcl_NewListObj(objc, objv);
	}
    }
    return Tcl_NewStringObj(command, numChars);
}

/*
 *----------------------------------------------------------------------
 *

    Tcl_Obj *const objv[],	/* An array of pointers to objects that are
				 * the words that make up the command. */
    const char *command,	/* Points to the beginning of the string
				 * representation of the command; this is used
				 * for traces. NULL if the string
				 * representation of the command is unknown is
				 * to be generated from (objc,objv), -1 if it
				 * is to be generated from bytecode source,
				 * with length ENSEMBLE_PSEUDO_COMMAND it is 
				 * to be determined from the ensemble context. 
				 * This is only needed the traces. */
    int length,			/* Number of bytes in command; if -1, all
				 * characters up to the first null byte are
				 * used. */
    int flags)			/* Collection of OR-ed bits that control the
				 * evaluation of the script. Only
				 * TCL_EVAL_GLOBAL and TCL_EVAL_INVOKE are
				 * currently supported. */

    const char *op;   /* Do not call it 'operator': C++ reserved */
    const char *expected;
    union {
	int numArgs;
	int identity;
    } i;
} TclOpCmdClientData;

/*
 * Special sentinel value for TclEvalObjvInternal's 'length' parameter to
 * cause it to retrieve command information for an ensemble from the
 * containing command (parameter 'command' is (char *)-1).
 */

#define ENSEMBLE_PSEUDO_COMMAND -2

/*
 *----------------------------------------------------------------
 * Procedures exported by tclBasic.c to be used within the engine.
 *----------------------------------------------------------------
 */

 * Results:
 *	If a command is found that encloses the program counter value, a
 *	pointer to the command's source is returned and the length of the
 *	source is stored at *lengthPtr. If multiple commands resulted in code
 *	at pc, information about the closest enclosing command is returned. If
 *	no matching command is found, NULL is returned and *lengthPtr is
 *	unchanged.
 *	As input parameter '*lengthPtr' could be used an ENSEMBLE_PSEUDO_COMMAND 
 *	to advise call of the ensemble command.
 *
 * Side effects:
 *	The CmdFrame at *cfPtr is updated.
 *
 *----------------------------------------------------------------------
 */

const char *
TclGetSrcInfoForCmd(
    Interp *iPtr,
    int *lenPtr)
{
    CmdFrame *cfPtr = iPtr->cmdFramePtr;
    const char *command;
    ByteCode *codePtr;
    int len;

    if (!cfPtr)
	return NULL;
    codePtr = (ByteCode *) cfPtr->data.tebc.codePtr;
    if (!codePtr)
	return NULL;
    if (!cfPtr->data.tebc.pc)
	return NULL;

    command = GetSrcInfoForPc((unsigned char *) cfPtr->data.tebc.pc,
	    codePtr, &len);

    /*
     * [sebres]: If ensemble call (sentinel length == ENSEMBLE_PSEUDO_COMMAND), 
     * shift string ptr to subcommand (string range -> range).
     */

    if (command && len && (lenPtr && *lenPtr == ENSEMBLE_PSEUDO_COMMAND) && codePtr->objArrayPtr) {
	Tcl_Obj *objPtr = codePtr->objArrayPtr[0];

	if (len > objPtr->length) {
	    command += objPtr->length + 1;
	    len -= objPtr->length + 1;
	}
    }

    if (lenPtr != NULL)
	*lenPtr = len;
    return command;
}

void
TclGetSrcInfoForPc(
    CmdFrame *cfPtr)
{
    ByteCode *codePtr = (ByteCode *) cfPtr->data.tebc.codePtr;

 *   [email protected]
 *
 * See the file "license.terms" for information on usage and redistribution of
 * this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

#include "tclInt.h"
#include "tclCompile.h"

/*
 * Thread-local storage used to avoid having a global lock on data that is not
 * limited to a single interpreter.
 */

typedef struct ThreadSpecificData {

	tempObjv = (Tcl_Obj **) TclStackAlloc(interp,
		(int) sizeof(Tcl_Obj *) * (objc - 2 + prefixObjc));
	memcpy(tempObjv, prefixObjv, sizeof(Tcl_Obj *) * prefixObjc);
	memcpy(tempObjv+prefixObjc, objv+2, sizeof(Tcl_Obj *) * (objc-2));

	/*
	 * Hand off to the target command.
	 * [sebres] call from ensemble using ENSEMBLE_PSEUDO_COMMAND to
	 * retrive subcommand from main ensemble.
	 */

	result = TclEvalObjvInternal(interp, objc-2+prefixObjc, tempObjv,
		/* call from TEBC, TclGetSrcInfoForCmd sentinel */(char *) -1, 
		ENSEMBLE_PSEUDO_COMMAND, TCL_EVAL_INVOKE);

	/*
	 * Clean up.
	 */

	TclStackFree(interp, tempObjv);
	Tcl_DecrRefCount(copyObj);