static int		SetLambdaFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr);
static int              ProcEatArgs(Tcl_Interp *interp,CallFrame *framePtr,Tcl_Obj *argspec,Tcl_Obj *values);

static Tcl_NRPostProc ApplyNR2;
static Tcl_NRPostProc InterpProcNR2;
static Tcl_NRPostProc Uplevel_Callback;

#undef TIP_479_AS_COMPILED_LOCALS 1
/*
 * The ProcBodyObjType type
 */

const Tcl_ObjType tclProcBodyType = {
    "procbody",			/* name for this type */
    ProcBodyFree,		/* FreeInternalRep function */

    TclVarHashTable *tablePtr,
    Tcl_Obj *key,
    int *newPtr)
{
    Tcl_HashEntry *hPtr = Tcl_CreateHashEntry(&tablePtr->table, key, newPtr);

    if (hPtr) {
        /* printf(" CREATED %s\n",Tcl_GetString(key)); */
	return VarHashGetValue(hPtr);
    } else {
	return NULL;
    }
}

void ProcSetLocalVar (
    CallFrame *framePtr,
    Tcl_Obj *varNamePtr, 	/* Scaler name */
    Tcl_Obj *valuePtr           /* Value to set */
) {
    int i, varLen, idx, isNew;
    const char *varName = TclGetStringFromObj(varNamePtr, &varLen);
    int localLen, localCt = framePtr->numCompiledLocals;
    Tcl_Obj **objPtrPtr = &framePtr->localCachePtr->varName0;
    const char *localNameStr;
    TclVarHashTable *tablePtr;	/* Points to the hashtable, if any, in which
				 * to look up the variable. */
    Var *varPtr;		/* Points to the Var structure returned for
				 * the variable. */

    varPtr = NULL;
    idx=-1;
    isNew=-1;
#ifdef TIP_479_AS_COMPILED_LOCALS
    for (i=0 ; i<localCt ; i++, objPtrPtr++) {
	register Tcl_Obj *objPtr = *objPtrPtr;

	if (objPtr) {
	    localNameStr = TclGetStringFromObj(objPtr, &localLen);
	    /* printf("Compiled Local %s %d len: %d\n",localNameStr,i, localLen); fflush(stdout); */
	    if ((varLen == localLen) && (varName[0] == localNameStr[0])
			&& !memcmp(varName, localNameStr, varLen)) {
		idx=i;
		/* printf("Compiled Locals Match %s %d\n",varName,i); fflush(stdout); */
		varPtr=(Var *) &framePtr->compiledLocals[i];
		break;
	    }
	}
    }
#endif
    if(!varPtr) {
        tablePtr = framePtr->varTablePtr;

        if (tablePtr == NULL) {
            tablePtr = ckalloc(sizeof(TclVarHashTable));
            TclInitVarHashTable(tablePtr, NULL);
            framePtr->varTablePtr = tablePtr;
            //printf("Created varTablePtr\n");
        }
        varPtr = VarHashCreateVar(tablePtr, varNamePtr, &isNew);
    }
    varPtr->flags=VAR_ARGUMENT;
    varPtr->value.objPtr=valuePtr;
    Tcl_IncrRefCount(valuePtr);
    /*
    printf("Wrote value for %s = %s %d %d %p\n",
       Tcl_GetString(varNamePtr),Tcl_GetString(valuePtr),idx,isNew,varPtr);
    */
}

int ProcEatArgs(
    Tcl_Interp *interp,
    CallFrame *framePtr,
    Tcl_Obj *argspec,
    Tcl_Obj *argsValuePtr

            continue;
        }
        if(Tcl_DictObjGet(interp,fieldspec,obj_const_mandatory,&mandatoryObj)!=TCL_OK) return TCL_ERROR;
        if(mandatoryObj) {
            if(Tcl_GetBooleanFromObj(interp,mandatoryObj,&mandatory)) return TCL_ERROR;
        }
        if(mandatory) {
            printf("Did not find %s\n",Tcl_GetString(fieldname));
            Tcl_AppendResult(interp,"Error: ", Tcl_GetString(fieldname), " is required", (char *)NULL);
            return TCL_ERROR;
        }
    }
    fflush(stdout);
    Tcl_DictObjDone(&search);
    return TCL_OK;
}

int Tcl_AtArgsObjCmd(
    ClientData clientData,
    Tcl_Interp *interp,

	    }
	    memcpy(localPtr->name, fieldValues[0], nameLength + 1);
	    if ((i == numArgs - 1)
		    && (localPtr->nameLength == 4)
		    && (localPtr->name[0] == 'a')
		    && (strcmp(localPtr->name, "args") == 0)) {
		localPtr->flags |= VAR_IS_ARGS;
#ifdef TIP_479_AS_COMPILED_LOCALS
		if(fieldCount == 2) {
		    /*
		    ** TIP 479
		    ** Use the otherwise ignored default field for the last
		    ** parameter named args as a dict-based specification for
		    ** named parameters
		    */

                    localPtr->nextPtr = NULL;
                    localPtr->nameLength = FieldLen;
                    localPtr->frameIndex = i;
	            localPtr->flags = VAR_ARGUMENT;
                    localPtr->resolveInfo = NULL;
		    localPtr->defValuePtr = argspec;
		    Tcl_IncrRefCount(localPtr->defValuePtr);
                    printf("named parameter %s # %d %d\n",Fieldname,procPtr->numCompiledLocals,localPtr->flags);

                    for (; !done ; Tcl_DictObjNext(&search, &fieldname, &fieldspec, &done)) {
                        /* Allocate one slot for each of the other named parameters */
                        Tcl_Obj *variable,*defaultObj,*mandatoryObj;
                        int mandatory=1;

                        variable=NULL;
                        defaultObj=NULL;

        	        procPtr->lastLocalPtr->nextPtr = localPtr;
 		        procPtr->lastLocalPtr = localPtr;
 		     	memcpy(localPtr->name, Fieldname, FieldLen + 1);
                        localPtr->nextPtr = NULL;
                        localPtr->nameLength = FieldLen;
                        localPtr->frameIndex = i;
	                localPtr->flags = VAR_ARGUMENT;
                        printf("named parameter %s # %d %d\n",Fieldname,procPtr->numCompiledLocals,localPtr->flags);
                        localPtr->resolveInfo = NULL;
                        if(defaultObj) {
                            localPtr->defValuePtr=defaultObj;
                            Tcl_IncrRefCount(localPtr->defValuePtr);
                        } else {
                            localPtr->defValuePtr=NULL;
                        }
		    }
		}
#endif
	    }
	}
        fflush(stdout);
	ckfree(fieldValues);
    }

    *procPtrPtr = procPtr;
    ckfree(argArray);
    return TCL_OK;

{
    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;

    /*
     * Make sure that the local cache of variable names and initial values has
     * been initialised properly .
     */
    if (localCt) {
	if (!codePtr->localCachePtr) {
	    InitLocalCache(procPtr) ;

    /*
     * When we get here, the last formal argument remains to be defined:
     * defPtr and varPtr point to the last argument to be initialized.
     */

    varPtr->flags = 0;
    if (defPtr && defPtr->flags & VAR_IS_ARGS) {
        Tcl_Obj *argsValuePtr;
        /*
        ** Build a conventional list of arguments
        ** past the last positional argument, and call it
        ** args
        */
        argsValuePtr = Tcl_NewListObj(argCt-i, argObjs+i);
        varPtr->value.objPtr = argsValuePtr;
	if (defPtr->value.objPtr) {
            /*
            ** TIP 479
            ** Feed dict values into compiled locals
            ** If a required parameter is missing ProcEatArgs
            ** will return TCL_ERROR.
            */
            if(ProcEatArgs(interp,framePtr,defPtr->value.objPtr,argsValuePtr)
               != TCL_OK) goto incorrectArgs;
        }
        Tcl_IncrRefCount(argsValuePtr);	/* Local var is a reference. */
    } else if (argCt == numArgs) {
	Tcl_Obj *objPtr = argObjs[i];

	varPtr->value.objPtr = objPtr;
	Tcl_IncrRefCount(objPtr);	/* Local var is a reference. */
    } else if ((argCt < numArgs) && defPtr && defPtr->value.objPtr) {

	if (!framePtr->nsPtr->compiledVarResProc
		&& !((Interp *)interp)->resolverPtr) {
	    memset(varPtr, 0, (localCt - numArgs)*sizeof(Var));
	} else {
	    InitResolvedLocals(interp, codePtr, varPtr, framePtr->nsPtr);
	}
    }










    return TCL_OK;

    /*
     * Initialise all compiled locals to avoid problems at DeleteLocalVars.
     */

  incorrectArgs: