static void		DupLambdaInternalRep(Tcl_Obj *objPtr,
			    Tcl_Obj *copyPtr);
static void		FreeLambdaInternalRep(Tcl_Obj *objPtr);
static int		InitArgsAndLocals(Tcl_Interp *interp,
			    Tcl_Obj *procNameObj, int skip);
static int		InitArgsWithOptions(Tcl_Interp *interp,
			    Tcl_Obj *procNameObj, Tcl_Obj *const *argObjs,
			    int numArgs, int *errorSet);
static int		InitArgWithUpvarSpec(Tcl_Interp *interp,
			    Var *varArrayPtr, CompiledLocal *localPtr,
			    ExtendedArgSpec *argSpecPtr, Tcl_Obj *objPtr,
			    int *errorSet);
static void		InitResolvedLocals(Tcl_Interp *interp,
			    ByteCode *codePtr, Var *defPtr,
			    Namespace *nsPtr);
static void		InitLocalCache(Proc *procPtr);
static void		ProcBodyDup(Tcl_Obj *srcPtr, Tcl_Obj *dupPtr);
static void		ProcBodyFree(Tcl_Obj *objPtr);
static int		ProcWrongNumArgs(Tcl_Interp *interp, int skip);

	    /*
	     * Handle '-name name'. This create a name group if not
	     * already created.
	     */

	    if ((localPtr->argSpecPtr != NULL)
		    && (localPtr->argSpecPtr->nameLength == 0)
		    && (localPtr->argSpecPtr->flags & VAR_UPVAR_ARG)) {
		Tcl_SetObjResult(interp, Tcl_NewStringObj(
			"-upvar is not allowed before first -name", -1));
		goto parseError;
	    }

	    length = strlen(fieldValues[i+1]);

	     * a name group.
	     */

	    if (lastArgSpecPtr == NULL) {
		Tcl_SetObjResult(interp, Tcl_NewStringObj(
			"-name required for -value", -1));
		goto parseError;
	    }
	    if (lastArgSpecPtr->flags & VAR_UPVAR_ARG) {
		Tcl_SetObjResult(interp, Tcl_NewStringObj(
			"-upvar and -value are not allowed together", -1));
		goto parseError;
	    }
	    if (lastArgSpecPtr->valuePtr != NULL) {
		Tcl_DecrRefCount(lastArgSpecPtr->valuePtr);
	    }
	    lastArgSpecPtr->valuePtr =
		    Tcl_NewStringObj(fieldValues[i+1], -1);
	    Tcl_IncrRefCount(lastArgSpecPtr->valuePtr);

		localPtr->argSpecPtr = argSpecPtr;
		lastArgSpecPtr = argSpecPtr;
	    } else {
		if (lastArgSpecPtr->flags & VAR_UPVAR_ARG) {
		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
			    "-upvar has already been set", -1));
		    goto parseError;
		}
		if (lastArgSpecPtr->valuePtr != NULL) {
		    Tcl_SetObjResult(interp, Tcl_NewStringObj(
			    "-upvar and -value are not allowed together", -1));
		    goto parseError;
		}
		lastArgSpecPtr->flags |= VAR_UPVAR_ARG;
	    }

	    length = strlen(fieldValues[i+1]);
	    if (length > 0) {
		upLocalPtr = ckalloc(TclOffset(CompiledLocal, name) + length+1);

{
    CallFrame *framePtr = ((Interp *)interp)->varFramePtr;
    register Proc *procPtr = framePtr->procPtr;
    ByteCode *codePtr = procPtr->bodyPtr->internalRep.twoPtrValue.ptr1;
    register Var *varPtr, *defPtr;
    int localCt = procPtr->numCompiledLocals, numArgs, argCt, i, imax;
    Tcl_Obj *const *argObjs;
    int errorSet = 0;

    /*
     * Make sure that the local cache of variable names and initial values has
     * been initialised properly .
     */

    if (localCt) {

	}
    }

    if ((procPtr->flags & PROC_HAS_EXT_ARG_SPEC) != 0) {
	int result;

	memset(varPtr, 0, numArgs*sizeof(Var));
	result = InitArgsWithOptions(interp, procNameObj, argObjs, argCt,
		&errorSet);
	varPtr += numArgs;
	if (result != TCL_OK) {
	    goto incorrectArgs;
	} else {
	    goto correctArgs;
	}
    }

  incorrectArgs:
    if ((skip != 1) &&
	    TclInitRewriteEnsemble(interp, skip-1, 0, framePtr->objv)) {
	TclNRAddCallback(interp, TclClearRootEnsemble, NULL, NULL, NULL, NULL);
    }
    memset(varPtr, 0,
	    ((framePtr->compiledLocals + localCt)-varPtr) * sizeof(Var));
    if (errorSet != 0) {
	return TCL_ERROR;
    }
    return ProcWrongNumArgs(interp, skip);
}

/*
 *----------------------------------------------------------------------
 *
 * InitArgsWithOptions --

static int
InitArgsWithOptions(
    register Tcl_Interp *interp,/* Interpreter in which procedure was
				 * invoked. */
    Tcl_Obj *procNameObj,	/* Procedure name for error reporting. */
    Tcl_Obj *const *argObjs,	/* Array of input arguments */
    int argCt,			/* Number of input arguments */
    int *errorSet)		/* Set to 1 if error is set here */
{
    CallFrame *framePtr = ((Interp *)interp)->varFramePtr;
    register Proc *procPtr = framePtr->procPtr;
    register Var *varPtr = framePtr->compiledLocals;
    int numArgs = procPtr->numArgs, iLocal, iArg;
    Tcl_Obj *objPtr;
    CompiledLocal *localPtr, *namedLocalPtr;

		    return TCL_ERROR;
		} else if (argSpecPtr->valuePtr) {
		    objPtr = argSpecPtr->valuePtr;
		} else if (iArg+1 < argCt) {
		    objPtr = argObjs[++iArg];
		    if (argSpecPtr->flags & VAR_UPVAR_ARG) {
			result = InitArgWithUpvarSpec(interp, varPtr,
				localPtr, argSpecPtr, objPtr, errorSet);
			if (result != TCL_OK) {
			    return result;
			}
			continue;
		    }
		} else {
		    return TCL_ERROR;

	     * Set normal or 'upvar' variable using next input argument.
	     */

	    objPtr = argObjs[iArg++];
	    if ((localPtr->argSpecPtr != NULL)
		    && (localPtr->argSpecPtr->flags & VAR_UPVAR_ARG)) {
		result = InitArgWithUpvarSpec(interp, varPtr, localPtr,
			argSpecPtr, objPtr, errorSet);
		if (result != TCL_OK) {
		    return result;
		}
	    } else {
		varPtr[iLocal].value.objPtr = objPtr;
		Tcl_IncrRefCount(objPtr);
	    }

InitArgWithUpvarSpec(
    Tcl_Interp *interp,		/* Interpreter in which procedure was
				 * invoked. */
    Var *varArrayPtr,		/* array of local variables */
    CompiledLocal *localPtr,	/* related variable */
    ExtendedArgSpec *argSpecPtr,
				/* related argument specification */
    Tcl_Obj *objPtr,		/* input object */
    int *errorSet)		/* Set to 1 if error is set here */
{
    register Var *varPtr = &(varArrayPtr[localPtr->frameIndex]);
    int result;

    if (varPtr->value.objPtr != NULL) {
	Tcl_DecrRefCount(varPtr->value.objPtr);
	varPtr->value.objPtr = NULL;
    }

    result = Tcl_UpVar(interp, "1", TclGetString(objPtr), localPtr->name, 0);
    if (result != TCL_OK) {
	return result;
    }

    if ((varPtr->value.linkPtr == NULL)
	    || (varPtr->value.linkPtr->value.objPtr == NULL)) {
	Tcl_SetObjResult(interp, Tcl_ObjPrintf(
		"wrong args: pass-by-name variable \"%s\" does not exist",
		TclGetString(objPtr)));
	Tcl_SetErrorCode(interp, "TCL", "WRONGARGS", NULL);
	*errorSet = 1;
	return TCL_ERROR;
    }

    if (localPtr->argSpecPtr->upvarNameIndex >= 0) {
	Var *varNamePtr = &(varArrayPtr[localPtr->argSpecPtr->upvarNameIndex]);
	if (varNamePtr->value.objPtr) {
	    Tcl_DecrRefCount(varNamePtr->value.objPtr);