* in precompiled scripts keep working.
 */

/* Type of value (0 is scalar) */
#define VAR_ARRAY		0x1
#define VAR_LINK		0x2
#define VAR_CONSTANT		0x10000
#define VAR_TYPE \
	(VAR_ARRAY | VAR_LINK | VAR_CONSTANT)

/* Type of storage (0 is compiled local) */
#define VAR_IN_HASHTABLE	0x4
#define VAR_DEAD_HASH		0x8
#define VAR_ARRAY_ELEMENT	0x1000
#define VAR_NAMESPACE_VAR	0x80	/* KEEP OLD VALUE for Itcl */

MODULE_SCOPE void	TclContinuationsEnterDerived(Tcl_Obj *objPtr,
			    Tcl_Size start, Tcl_Size *clNext);
MODULE_SCOPE ContLineLoc *TclContinuationsGet(Tcl_Obj *objPtr);
MODULE_SCOPE void	TclContinuationsCopy(Tcl_Obj *objPtr,
			    Tcl_Obj *originObjPtr);
MODULE_SCOPE Tcl_Size	TclConvertElement(const char *src, Tcl_Size length,
			    char *dst, int flags);
MODULE_SCOPE int	TclCopyNamespaceProcedures(Tcl_Interp *interp,
			    Namespace *srcNsPtr, Namespace *tgtNsPtr);
MODULE_SCOPE int	TclCopyNamespaceVariables(Tcl_Interp *interp,
			    Namespace *originNs, Namespace *targetNs);
MODULE_SCOPE Tcl_Command TclCreateObjCommandInNs(Tcl_Interp *interp,
			    const char *cmdName, Tcl_Namespace *nsPtr,
			    Tcl_ObjCmdProc *proc, void *clientData,
			    Tcl_CmdDeleteProc *deleteProc);
MODULE_SCOPE Tcl_Command TclCreateEnsembleInNs(Tcl_Interp *interp,
			    const char *name, Tcl_Namespace *nameNamespacePtr,
			    Tcl_Namespace *ensembleNamespacePtr, int flags);

 */

#define DCM(name,visibility,proc) \
    {name,visibility,\
	{TCL_OO_METHOD_VERSION_CURRENT,"core method: "#name,proc,NULL,NULL}}

static const DeclaredClassMethod objMethods[] = {
    DCM("<cloned>", 0,	TclOO_Object_Cloned),
    DCM("destroy", 1,	TclOO_Object_Destroy),
    DCM("eval", 0,	TclOO_Object_Eval),
    DCM("unknown", 0,	TclOO_Object_Unknown),
    DCM("variable", 0,	TclOO_Object_LinkVar),
    DCM("varname", 0,	TclOO_Object_VarName),
    {NULL, 0, {0, NULL, NULL, NULL, NULL}}
}, clsMethods[] = {

"package ifneeded tcl::oo " TCLOO_PATCHLEVEL " {# Already present, OK?};"
"namespace eval ::oo {"
"    variable version " TCLOO_VERSION " patchlevel " TCLOO_PATCHLEVEL
"};";
/* "tcl_findLibrary tcloo $oo::version $oo::version" */
/* " tcloo.tcl OO_LIBRARY oo::library;"; */







/*
 * The actual definition of the variable holding the TclOO stub table.
 */

MODULE_SCOPE const TclOOStubs tclOOStubs;

/*

     */

    if (TclOODefineSlots(fPtr) != TCL_OK) {
	return TCL_ERROR;
    }

    MakeAdditionalClasses(fPtr, define, objdef);
    return TCL_OK;





}

/*
 * ----------------------------------------------------------------------
 *
 * InitClassSystemRoots --
 *

    TclOOClassSetMixins(interp, oPtr->classPtr, 1, &mixin);
    return TclNRObjectContextInvokeNext(interp, context, objc, objv, skip);
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_Object_Cloned --
 *
 *	Handler for cloning objects that clones basic bits (only!) of the
 *	object's namespace. Non-procedures, traces, sub-namespaces, etc. need
 *	more complex (and class-specific) handling.
 *
 * ----------------------------------------------------------------------
 */
int
TclOO_Object_Cloned(
    TCL_UNUSED(void *),
    Tcl_Interp *interp,		/* Interpreter for error reporting. */
    Tcl_ObjectContext context,	/* The object/call context. */
    int objc,			/* Number of arguments. */
    Tcl_Obj *const *objv)	/* The actual arguments. */
{
    int skip = Tcl_ObjectContextSkippedArgs(context);
    if (objc != skip + 1) {
	Tcl_WrongNumArgs(interp, skip, objv, "originObject");
	return TCL_ERROR;
    }
    Object *targetObject = (Object *) Tcl_ObjectContextObject(context);
    Object *originObject = (Object *) Tcl_GetObjectFromObj(interp, objv[skip]);
    if (!originObject) {
	return TCL_ERROR;
    }

    Namespace *originNs = (Namespace *) originObject->namespacePtr;
    Namespace *targetNs = (Namespace *) targetObject->namespacePtr;
    if (TclCopyNamespaceProcedures(interp, originNs, targetNs) != TCL_OK) {
	return TCL_ERROR;
    }
    return TclCopyNamespaceVariables(interp, originNs, targetNs);
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_Object_Destroy --
 *
 *	Implementation for oo::object->destroy method.
 *
 * ----------------------------------------------------------------------
 */

	return TCL_ERROR;
    }
    Tcl_SetObjResult(interp, Tcl_ObjPrintf("%s:: oo ::delegate",
	    clsPtr->thisPtr->namespacePtr->fullName));
    return TCL_OK;
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_Singleton_New, MarkAsSingleton --
 *
 *	Implementation for oo::singleton->new method.
 *
 * ----------------------------------------------------------------------
 */

int
TclOO_Singleton_New(
    TCL_UNUSED(void *),
    Tcl_Interp *interp,		/* Interpreter in which to create the object;
				 * also used for error reporting. */
    Tcl_ObjectContext context,	/* The object/call context. */
    int objc,			/* Number of arguments. */

	mixins[0] = singInst; 
	TclOOObjectSetMixins(oPtr, mixinc + 1, mixins);
	TclStackFree(interp, mixins);
    }
    return result;
}

/*
 * ----------------------------------------------------------------------
 *
 * TclOO_SingletonInstance_Destroy, TclOO_SingletonInstance_Cloned --
 *
 *	Implementation for oo::SingletonInstance->destroy method and its
 *	cloning callback method.
 *
 * ----------------------------------------------------------------------
 */

int
TclOO_SingletonInstance_Destroy(
    TCL_UNUSED(void *),
    Tcl_Interp *interp,		/* Interpreter for error reporting. */
    TCL_UNUSED(Tcl_ObjectContext),
    TCL_UNUSED(int),
    TCL_UNUSED(Tcl_Obj *const *))

 */

MODULE_SCOPE Tcl_MethodCallProc	TclOO_Class_Cloned;
MODULE_SCOPE Tcl_MethodCallProc	TclOO_Class_Constructor;
MODULE_SCOPE Tcl_MethodCallProc	TclOO_Class_Create;
MODULE_SCOPE Tcl_MethodCallProc	TclOO_Class_CreateNs;
MODULE_SCOPE Tcl_MethodCallProc	TclOO_Class_New;
MODULE_SCOPE Tcl_MethodCallProc	TclOO_Object_Cloned;
MODULE_SCOPE Tcl_MethodCallProc	TclOO_Object_Destroy;
MODULE_SCOPE Tcl_MethodCallProc	TclOO_Object_Eval;
MODULE_SCOPE Tcl_MethodCallProc	TclOO_Object_LinkVar;
MODULE_SCOPE Tcl_MethodCallProc	TclOO_Object_Unknown;
MODULE_SCOPE Tcl_MethodCallProc	TclOO_Object_VarName;
MODULE_SCOPE Tcl_MethodCallProc TclOO_Configurable_Configure;
MODULE_SCOPE Tcl_MethodCallProc TclOO_Configurable_Constructor;

    }
    hePtr = Tcl_FindHashEntry(procPtr->iPtr->linePBodyPtr, procPtr);
    if (hePtr == NULL) {
	return NULL;
    }
    return (CmdFrame *) Tcl_GetHashValue(hePtr);
}

/*
 *----------------------------------------------------------------------
 *
 * TclCopyNamespaceProcedures --
 *
 *	Copy procedures from one namespace into another.
 *
 * Results:
 *	A standard Tcl result code.
 *
 * Side effects:
 *	Modifies the target namespace's commands.
 *
 *----------------------------------------------------------------------
 */

// Duplicate an argument to a procedure.
static inline int
DuplicateArgument(
    Proc *newProc,
    const CompiledLocal *origLocal,
    Tcl_Size i)
{
    const char *argname = origLocal->name;
    Tcl_Size nameLength = origLocal->nameLength;

    // Allocate an entry in the runtime procedure frame's list of local
    // variables for the argument.

    CompiledLocal *localPtr = (CompiledLocal *)Tcl_AttemptAlloc(
	    offsetof(CompiledLocal, name) + 1U + nameLength);
    if (!localPtr) {
	return TCL_ERROR;
    }
    if (newProc->firstLocalPtr == NULL) {
	newProc->firstLocalPtr = newProc->lastLocalPtr = localPtr;
    } else {
	newProc->lastLocalPtr->nextPtr = localPtr;
	newProc->lastLocalPtr = localPtr;
    }
    localPtr->nextPtr = NULL;
    localPtr->nameLength = nameLength;
    localPtr->frameIndex = i;
    localPtr->flags = VAR_ARGUMENT;
    localPtr->resolveInfo = NULL;
    localPtr->defValuePtr = origLocal->defValuePtr;
    if (localPtr->defValuePtr) {
	Tcl_IncrRefCount(localPtr->defValuePtr);
    }
    memcpy(localPtr->name, argname, nameLength + 1);
    if (origLocal->flags & VAR_IS_ARGS) {
	localPtr->flags |= VAR_IS_ARGS;
    }
    return TCL_OK;
}

// Duplicate a procedure into a different namespace.
static int
DuplicateProc(
    Tcl_Interp *interp,
    Namespace *nsPtr,
    const char *cmdName,
    const Proc *origProc,
    const Command *origCmd)
{
    Interp *iPtr = (Interp *) interp;

    // Duplicate the string of body, not the bytecode.
    Tcl_Size length;
    const char *bytes = TclGetStringFromObj(origProc->bodyPtr, &length);
    Tcl_Obj *bodyPtr = Tcl_NewStringObj(bytes, length);
    TclContinuationsCopy(bodyPtr, origProc->bodyPtr);
    Tcl_IncrRefCount(bodyPtr);

    // The new procedure record.
    Proc *newProc = (Proc *) Tcl_Alloc(sizeof(Proc));
    newProc->iPtr = iPtr;
    newProc->refCount = 1;
    newProc->bodyPtr = bodyPtr;
    newProc->numArgs = origProc->numArgs;
    newProc->numCompiledLocals = origProc->numArgs;
    newProc->firstLocalPtr = NULL;
    newProc->lastLocalPtr = NULL;

    // Work through the original arguments, duplicating them.
    const CompiledLocal *origLocal = origProc->firstLocalPtr;
    for (Tcl_Size i = 0; i < newProc->numArgs; i++) {
	if (DuplicateArgument(newProc, origLocal, i) != TCL_OK) {
	    // Don't set the interp result here. Since a malloc just failed,
	    // first clean up some memory before doing that */
	    goto procError;
	}
	origLocal = origLocal->nextPtr;
    }

    // Create the new command backed by the procedure.
    newProc->cmdPtr = (Command *) TclNRCreateCommandInNs(interp, cmdName,
	    (Tcl_Namespace *) nsPtr, TclObjInterpProc, NRInterpProc, newProc,
	    TclProcDeleteProc);

    // TIP #280: Duplicate the origin information (if we have it).
    Tcl_HashEntry *origHePtr = Tcl_FindHashEntry(iPtr->linePBodyPtr, origProc);
    if (origHePtr) {
	CmdFrame *newCfPtr = (CmdFrame *) Tcl_Alloc(sizeof(CmdFrame));
	const CmdFrame *origCfPtr = (CmdFrame *) Tcl_GetHashValue(origHePtr);

	// Copy info, then fix up bits that need different treatment.
	memcpy(newCfPtr, origCfPtr, sizeof(CmdFrame));
	newCfPtr->line = (int *)Tcl_Alloc(sizeof(int));
	newCfPtr->line[0] = origCfPtr->line[0];
	Tcl_IncrRefCount(newCfPtr->data.eval.path);

	Tcl_HashEntry *hePtr = Tcl_CreateHashEntry(iPtr->linePBodyPtr,
		newProc, NULL);
	Tcl_SetHashValue(hePtr, newCfPtr);
    }

    // Optimize for no-op procs. Note that this is simpler than in [proc]; we
    // just see whether we've got the compiler in the old command!
    if (origCmd->compileProc == TclCompileNoOp) {
	newProc->cmdPtr->compileProc = TclCompileNoOp;
    }

    return TCL_OK;

  procError:
    // Delete the data allocated so far
    Tcl_DecrRefCount(bodyPtr);
    while (newProc->firstLocalPtr != NULL) {
	CompiledLocal *localPtr = newProc->firstLocalPtr;
	newProc->firstLocalPtr = localPtr->nextPtr;

	if (localPtr->defValuePtr != NULL) {
	    Tcl_DecrRefCount(localPtr->defValuePtr);
	}

	Tcl_Free(localPtr);
    }
    Tcl_Free(newProc);
    // Complain about the failure to allocate.
    Tcl_SetObjResult(interp, Tcl_ObjPrintf(
	    "procedure \"%s\": arg list contains too many (%"
	    TCL_SIZE_MODIFIER "d) entries", cmdName, origProc->numArgs));
    Tcl_SetErrorCode(interp, "TCL", "OPERATION", "PROC",
	    TOOMANYARGS, (char *)NULL);
    return TCL_ERROR;
}

// Duplicate all the procedures in a namespace into another (new) namespace.
int
TclCopyNamespaceProcedures(
    Tcl_Interp *interp,
    Namespace *srcNsPtr,	// Where to copy from.
    Namespace *tgtNsPtr)	// Where to copy to.
{
    Tcl_HashSearch search;
    if (srcNsPtr == tgtNsPtr) {
	Tcl_Panic("cannot copy procedures from one namespace to itself");
    }
    for (Tcl_HashEntry *entryPtr = Tcl_FirstHashEntry(&srcNsPtr->cmdTable, &search);
	    entryPtr; entryPtr = Tcl_NextHashEntry(&search)) {
	const char *cmdName = (const char *)
		Tcl_GetHashKey(&srcNsPtr->cmdTable, entryPtr);
	Command *cmdPtr = (Command *) Tcl_GetHashValue(entryPtr);

	// For non-procedures, check if this is an import of a procedure; those
	// also get copied.
	if (!TclIsProc(cmdPtr)) {
	    Command *realCmdPtr = (Command *)
		    TclGetOriginalCommand((Tcl_Command) cmdPtr);
	    if (!realCmdPtr || !TclIsProc(realCmdPtr)) {
		continue;
	    }
	    cmdPtr = realCmdPtr;
	}

	// Make the copy
	Proc *procPtr = (Proc *) cmdPtr->objClientData;
	if (DuplicateProc(interp, tgtNsPtr, cmdName, procPtr, cmdPtr) != TCL_OK) {
	    return TCL_ERROR;
	}
    }
    return TCL_OK;
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:

    }
    tablePtr->defaultObj = defaultObj;
    if (tablePtr->defaultObj) {
	Tcl_IncrRefCount(tablePtr->defaultObj);
	Tcl_IncrRefCount(tablePtr->defaultObj);
    }
}

/*----------------------------------------------------------------------
 *
 * TclCopyNamespaceVariables --
 *
 *	This copies the variables of one namespace (the source) to another
 *	(the target). It skips variables in the source that have the same name
 *	in the target.
 *
 * Results:
 *	Returns a standard Tcl result.
 *
 * Side effects:
 *	May run traces on the source variables.
 *
 *----------------------------------------------------------------------
 */

// Copy an array from one namespace to another.
// This is basically [array set $tgt [array get $src]] but optimised.
static int
CopyNSArray(
    Tcl_Interp *interp,
    Var *srcAryPtr,
    Var *tgtAryPtr,
    Tcl_Obj *arrayName)
{
    // List the elements of the array prior to traces.
    Tcl_Obj *nameList = Tcl_NewObj();
    Tcl_HashSearch search;
    for (Var *varPtr2 = VarHashFirstVar(srcAryPtr->value.tablePtr, &search);
	    varPtr2; varPtr2 = VarHashNextVar(&search)) {
	if (TclIsVarUndefined(varPtr2)) {
	    continue;
	}
	Tcl_ListObjAppendElement(NULL, nameList, VarHashGetKey(varPtr2));
    }

    // Make sure the Var structure of the array is not removed by a trace
    // while we're working.
    VarHashRefCount(srcAryPtr)++;

    Tcl_Size count;
    Tcl_Obj **names;
    TclListObjGetElements(NULL, nameList, &count, &names);

    // Init the target array if necessary
    if (!TclIsVarArray(tgtAryPtr)) {
	TclInitArrayVar(tgtAryPtr);
    }
    // Make sure it won't go away
    VarHashRefCount(tgtAryPtr)++;

    // Copy elements!
    for (Tcl_Size i=0 ; i<count ; i++) {
	Tcl_Obj *elemName = names[i];

	// Read the element in the source; may invoke read traces.
	Var *srcElem = TclLookupArrayElement(interp, arrayName, elemName,
		TCL_LEAVE_ERR_MSG, "read", 0, 0, srcAryPtr, TCL_INDEX_NONE);
	if (!srcElem) {
	    if (TclIsVarArray(srcAryPtr)) {
		continue;
	    }
	    goto errorCopyingElement;
	}
	Tcl_Obj *valueObj = TclPtrGetVarIdx(interp, srcElem, srcAryPtr,
		arrayName, elemName, TCL_LEAVE_ERR_MSG, TCL_INDEX_NONE);
	if (!valueObj) {
	    if (TclIsVarArray(srcAryPtr)) {
		continue;
	    }
	    goto errorCopyingElement;
	}

	// Write the element in the target; may invoke write traces
	Var *tgtElem = TclLookupArrayElement(interp, arrayName, elemName,
		TCL_LEAVE_ERR_MSG, "write", 0, 1, tgtAryPtr, TCL_INDEX_NONE);
	if (!tgtElem) {
	    goto errorCopyingElement;
	}
	if (TclPtrSetVarIdx(interp, tgtElem, tgtAryPtr, arrayName, elemName,
		valueObj, TCL_LEAVE_ERR_MSG, TCL_INDEX_NONE) == NULL) {
	    goto errorCopyingElement;
	}
    }

    // Clean up
    VarHashRefCount(srcAryPtr)--;
    VarHashRefCount(tgtAryPtr)--;
    Tcl_BounceRefCount(nameList);
    return TCL_OK;

  errorCopyingElement:
    VarHashRefCount(srcAryPtr)--;
    VarHashRefCount(tgtAryPtr)--;
    Tcl_BounceRefCount(nameList);
    return TCL_ERROR;
}

// Copy variables from one namespace to another.
int
TclCopyNamespaceVariables(
    Tcl_Interp *interp,
    Namespace *originNs,
    Namespace *targetNs)
{
    Var *srcVarPtr;
    Tcl_HashSearch search;

    if (targetNs == originNs) {
	Tcl_Panic("cannot copy namespace variables to itself");
    }

  restartScan:
    for (srcVarPtr=VarHashFirstVar(&originNs->varTable, &search);
	    srcVarPtr!=NULL ; srcVarPtr=VarHashNextVar(&search)) {
	Tcl_Obj *nameObj = VarHashGetKey(srcVarPtr), *valueObj;
	int isNew, restart = 0;

	Var *tgtVarPtr = VarHashCreateVar(&targetNs->varTable, nameObj, &isNew);
	if (!tgtVarPtr || !isNew) {
	    // If we couldn't make it or it existed, we skip.
	    // This means that a variable that triggered a rescan because of
	    // a trace won't do the second time round.
	    continue;
	}
	// Mark this like [variable] does
	TclSetVarNamespaceVar(tgtVarPtr);
	if (TclIsVarUndefined(srcVarPtr)) {
	    continue;
	}
	switch (srcVarPtr->flags & VAR_TYPE) {
	case VAR_ARRAY:
	    if (srcVarPtr->flags & VAR_ALL_TRACES) {
		restart = 1;
	    }
	    if (CopyNSArray(interp, srcVarPtr, tgtVarPtr, nameObj) != TCL_OK) {
		return TCL_ERROR;
	    }
	    break;
	case VAR_LINK:
	    // Links don't have traces
	    while (TclIsVarLink(srcVarPtr)) {
		srcVarPtr = srcVarPtr->value.linkPtr;
	    }
	    TclSetVarLink(tgtVarPtr);
	    tgtVarPtr->value.linkPtr = srcVarPtr;
	    if (TclIsVarInHash(srcVarPtr)) {
		VarHashRefCount(srcVarPtr)++;
	    }
	    break;
	default:
	    if (srcVarPtr->flags & VAR_ALL_TRACES) {
		restart = 1;
	    }
	    valueObj = TclPtrGetVarIdx(interp, srcVarPtr, NULL, nameObj, NULL,
		    TCL_LEAVE_ERR_MSG, TCL_INDEX_NONE);
	    if (!valueObj) {
		return TCL_ERROR;
	    }
	    tgtVarPtr->value.objPtr = valueObj;
	    Tcl_IncrRefCount(valueObj);
	    if (srcVarPtr->flags & VAR_CONSTANT) {
		tgtVarPtr->flags |= VAR_CONSTANT;
	    }
	    break;
	}
	if (restart) {
	    // A trace existed on a variable we touched, so we must rescan
	    goto restartScan;
	}
    }
    return TCL_OK;
}

/*
 * Local Variables:
 * mode: c
 * c-basic-offset: 4
 * fill-column: 78
 * End:

tclNamesp.o: $(GENERIC_DIR)/tclNamesp.c $(COMPILEHDR)
	$(CC) -c $(CC_SWITCHES) $(GENERIC_DIR)/tclNamesp.c

tclNotify.o: $(GENERIC_DIR)/tclNotify.c
	$(CC) -c $(CC_SWITCHES) $(GENERIC_DIR)/tclNotify.c

tclOO.o: $(GENERIC_DIR)/tclOO.c
	$(CC) -c $(CC_SWITCHES) $(GENERIC_DIR)/tclOO.c

tclOOBasic.o: $(GENERIC_DIR)/tclOOBasic.c
	$(CC) -c $(CC_SWITCHES) $(GENERIC_DIR)/tclOOBasic.c

tclOOCall.o: $(GENERIC_DIR)/tclOOCall.c
	$(CC) -c $(CC_SWITCHES) $(GENERIC_DIR)/tclOOCall.c

	@echo "This warning can be safely ignored, do not report as a bug!"

$(GENERIC_DIR)/tclOOStubInit.c: $(GENERIC_DIR)/tclOO.decls
	@echo "Warning: tclOOStubInit.c may be out of date."
	@echo "Developers may want to run \"make genstubs\" to regenerate."
	@echo "This warning can be safely ignored, do not report as a bug!"






genstubs:
	$(NATIVE_TCLSH) $(TOOL_DIR)/genStubs.tcl $(GENERIC_DIR) \
		$(GENERIC_DIR)/tcl.decls $(GENERIC_DIR)/tclInt.decls \
		$(GENERIC_DIR)/tclTomMath.decls
	$(NATIVE_TCLSH) $(TOOL_DIR)/genStubs.tcl $(GENERIC_DIR) \
		$(GENERIC_DIR)/tclOO.decls





#
# Target to check that all exported functions have an entry in the stubs
# tables.
#

checkstubs: $(TCL_LIB_FILE)
	-@for i in `nm -p $(TCL_LIB_FILE) \

%.${OBJEXT}: %.c
	$(CC) -c $(CC_SWITCHES) -DBUILD_tcl @DEPARG@ $(CC_OBJNAME)

.rc.$(RES):
	$(RC) @RC_OUT@ $@ @RC_TYPE@ @RC_DEFINES@ @RC_INCLUDE@ "$(GENERIC_DIR_NATIVE)" @RC_INCLUDE@ "$(WIN_DIR_NATIVE)" @DEPARG@



#--------------------------------------------------------------------------
# Minizip implementation
#--------------------------------------------------------------------------
adler32.$(HOST_OBJEXT):
	$(HOST_CC) -o $@ -I$(ZLIB_DIR) -c $(ZLIB_DIR)/adler32.c

compress.$(HOST_OBJEXT):

$(GENERIC_DIR)/tclStubInit.c: $(GENERIC_DIR)/tcl.decls \
		$(GENERIC_DIR)/tclInt.decls
	@echo "Warning: tclStubInit.c may be out of date."
	@echo "Developers may want to run \"make genstubs\" to regenerate."
	@echo "This warning can be safely ignored, do not report as a bug!"






genstubs:
	$(TCL_EXE) "$(TOOL_DIR_NATIVE)/genStubs.tcl" \
	    "$(GENERIC_DIR_NATIVE)" \
	    "$(GENERIC_DIR_NATIVE)/tcl.decls" \
	    "$(GENERIC_DIR_NATIVE)/tclInt.decls" \
	    "$(GENERIC_DIR_NATIVE)/tclTomMath.decls"
	$(TCL_EXE) "$(TOOL_DIR_NATIVE)/genStubs.tcl" \
	    "$(GENERIC_DIR_NATIVE)" \
	    "$(GENERIC_DIR_NATIVE)/tclOO.decls"






#
# This target creates the HTML folder for Tcl & Tk and places it in
# DISTDIR/html. It uses the tcltk-man2html.tcl tool from the Tcl group's tool
# workspace. It depends on the Tcl & Tk being in directories called tcl9.* &
# tk8.* up two directories from the TOOL_DIR.
#