From 40bb3c1c5474de09c765ddb9a90c5126d08e38f5 Mon Sep 17 00:00:00 2001
From: nijtmans <nijtmans>
Date: Wed, 15 Sep 2010 07:33:54 +0000
Subject: [Patch 3034251] backport ttkGenStubs.tcl features to genStubs.tcl.
 Make the "generic" argument in the *.decls files optional (no change to any
 tcl*Decls.h files) This allows genStubs.tcl to generate the ttk stub files as
 well, while keeping full compatibility with existing *.decls files.

---
 ChangeLog                |   10 +
 generic/tcl.decls        | 1261 +++++++++++++++++++++++-----------------------
 generic/tclInt.decls     |  495 +++++++++---------
 generic/tclOO.decls      |   93 ++--
 generic/tclTomMath.decls |  125 ++---
 tools/genStubs.tcl       |   52 +-
 6 files changed, 1047 insertions(+), 989 deletions(-)

diff --git a/ChangeLog b/ChangeLog
index a074faa..b98065a 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,13 @@
+2010-09-15  Jan Nijtmans  <nijtmans@users.sf.net>
+
+	* tools/genStubs.tcl   [Patch 3034251] backport ttkGenStubs.tcl
+	* generic/tcl.decls    features to genStubs.tcl. Make the "generic"
+	* generic/tclInt.decls argument in the *.decls files optional
+	* generic/tclOO.decls  (no change to any tcl*Decls.h files)
+	* generic/tclTomMath.decls
+	This allows genStubs.tcl to generate the ttk stub files as well,
+	while keeping full compatibility with existing *.decls files.
+
 2010-09-14  Jan Nijtmans  <nijtmans@users.sf.net>
 
 	* win/tclWinPort.h:  Allow all Win2000+ API entries in Tcl
diff --git a/generic/tcl.decls b/generic/tcl.decls
index b871151..f7c5d4f 100644
--- a/generic/tcl.decls
+++ b/generic/tcl.decls
@@ -12,7 +12,7 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #
-# RCS: @(#) $Id: tcl.decls,v 1.180 2010/08/31 20:48:16 nijtmans Exp $
+# RCS: @(#) $Id: tcl.decls,v 1.181 2010/09/15 07:33:54 nijtmans Exp $
 
 library tcl
 
@@ -23,45 +23,46 @@ library tcl
 
 interface tcl
 hooks {tclPlat tclInt tclIntPlat}
+scspec EXTERN
 
 # Declare each of the functions in the public Tcl interface.  Note that
 # the an index should never be reused for a different function in order
 # to preserve backwards compatibility.
 
-declare 0 generic {
+declare 0 {
     int Tcl_PkgProvideEx(Tcl_Interp *interp, const char *name,
 	    const char *version, const void *clientData)
 }
-declare 1 generic {
+declare 1 {
     CONST84_RETURN char *Tcl_PkgRequireEx(Tcl_Interp *interp,
 	    const char *name, const char *version, int exact,
 	    void *clientDataPtr)
 }
-declare 2 generic {
+declare 2 {
     void Tcl_Panic(const char *format, ...)
 }
-declare 3 generic {
+declare 3 {
     char *Tcl_Alloc(unsigned int size)
 }
-declare 4 generic {
+declare 4 {
     void Tcl_Free(char *ptr)
 }
-declare 5 generic {
+declare 5 {
     char *Tcl_Realloc(char *ptr, unsigned int size)
 }
-declare 6 generic {
+declare 6 {
     char *Tcl_DbCkalloc(unsigned int size, const char *file, int line)
 }
-declare 7 generic {
+declare 7 {
     void Tcl_DbCkfree(char *ptr, const char *file, int line)
 }
-declare 8 generic {
+declare 8 {
     char *Tcl_DbCkrealloc(char *ptr, unsigned int size,
 	    const char *file, int line)
 }
 
 # Tcl_CreateFileHandler and Tcl_DeleteFileHandler are only available on unix,
-# but they are part of the old generic interface, so we include them here for
+# but they are part of the old interface, so we include them here for
 # compatibility reasons.
 
 declare 9 unix {
@@ -71,533 +72,533 @@ declare 9 unix {
 declare 10 unix {
     void Tcl_DeleteFileHandler(int fd)
 }
-declare 11 generic {
+declare 11 {
     void Tcl_SetTimer(const Tcl_Time *timePtr)
 }
-declare 12 generic {
+declare 12 {
     void Tcl_Sleep(int ms)
 }
-declare 13 generic {
+declare 13 {
     int Tcl_WaitForEvent(const Tcl_Time *timePtr)
 }
-declare 14 generic {
+declare 14 {
     int Tcl_AppendAllObjTypes(Tcl_Interp *interp, Tcl_Obj *objPtr)
 }
-declare 15 generic {
+declare 15 {
     void Tcl_AppendStringsToObj(Tcl_Obj *objPtr, ...)
 }
-declare 16 generic {
+declare 16 {
     void Tcl_AppendToObj(Tcl_Obj *objPtr, const char *bytes, int length)
 }
-declare 17 generic {
+declare 17 {
     Tcl_Obj *Tcl_ConcatObj(int objc, Tcl_Obj *const objv[])
 }
-declare 18 generic {
+declare 18 {
     int Tcl_ConvertToType(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    const Tcl_ObjType *typePtr)
 }
-declare 19 generic {
+declare 19 {
     void Tcl_DbDecrRefCount(Tcl_Obj *objPtr, const char *file, int line)
 }
-declare 20 generic {
+declare 20 {
     void Tcl_DbIncrRefCount(Tcl_Obj *objPtr, const char *file, int line)
 }
-declare 21 generic {
+declare 21 {
     int Tcl_DbIsShared(Tcl_Obj *objPtr, const char *file, int line)
 }
-declare 22 generic {
+declare 22 {
     Tcl_Obj *Tcl_DbNewBooleanObj(int boolValue, const char *file, int line)
 }
-declare 23 generic {
+declare 23 {
     Tcl_Obj *Tcl_DbNewByteArrayObj(const unsigned char *bytes, int length,
 	    const char *file, int line)
 }
-declare 24 generic {
+declare 24 {
     Tcl_Obj *Tcl_DbNewDoubleObj(double doubleValue, const char *file,
 	    int line)
 }
-declare 25 generic {
+declare 25 {
     Tcl_Obj *Tcl_DbNewListObj(int objc, Tcl_Obj *const *objv,
 	    const char *file, int line)
 }
-declare 26 generic {
+declare 26 {
     Tcl_Obj *Tcl_DbNewLongObj(long longValue, const char *file, int line)
 }
-declare 27 generic {
+declare 27 {
     Tcl_Obj *Tcl_DbNewObj(const char *file, int line)
 }
-declare 28 generic {
+declare 28 {
     Tcl_Obj *Tcl_DbNewStringObj(const char *bytes, int length,
 	    const char *file, int line)
 }
-declare 29 generic {
+declare 29 {
     Tcl_Obj *Tcl_DuplicateObj(Tcl_Obj *objPtr)
 }
-declare 30 generic {
+declare 30 {
     void TclFreeObj(Tcl_Obj *objPtr)
 }
-declare 31 generic {
+declare 31 {
     int Tcl_GetBoolean(Tcl_Interp *interp, const char *src, int *boolPtr)
 }
-declare 32 generic {
+declare 32 {
     int Tcl_GetBooleanFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    int *boolPtr)
 }
-declare 33 generic {
+declare 33 {
     unsigned char *Tcl_GetByteArrayFromObj(Tcl_Obj *objPtr, int *lengthPtr)
 }
-declare 34 generic {
+declare 34 {
     int Tcl_GetDouble(Tcl_Interp *interp, const char *src, double *doublePtr)
 }
-declare 35 generic {
+declare 35 {
     int Tcl_GetDoubleFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    double *doublePtr)
 }
-declare 36 generic {
+declare 36 {
     int Tcl_GetIndexFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    CONST84 char *const *tablePtr, const char *msg, int flags, int *indexPtr)
 }
-declare 37 generic {
+declare 37 {
     int Tcl_GetInt(Tcl_Interp *interp, const char *src, int *intPtr)
 }
-declare 38 generic {
+declare 38 {
     int Tcl_GetIntFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *intPtr)
 }
-declare 39 generic {
+declare 39 {
     int Tcl_GetLongFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, long *longPtr)
 }
-declare 40 generic {
+declare 40 {
     CONST86 Tcl_ObjType *Tcl_GetObjType(const char *typeName)
 }
-declare 41 generic {
+declare 41 {
     char *Tcl_GetStringFromObj(Tcl_Obj *objPtr, int *lengthPtr)
 }
-declare 42 generic {
+declare 42 {
     void Tcl_InvalidateStringRep(Tcl_Obj *objPtr)
 }
-declare 43 generic {
+declare 43 {
     int Tcl_ListObjAppendList(Tcl_Interp *interp, Tcl_Obj *listPtr,
 	    Tcl_Obj *elemListPtr)
 }
-declare 44 generic {
+declare 44 {
     int Tcl_ListObjAppendElement(Tcl_Interp *interp, Tcl_Obj *listPtr,
 	    Tcl_Obj *objPtr)
 }
-declare 45 generic {
+declare 45 {
     int Tcl_ListObjGetElements(Tcl_Interp *interp, Tcl_Obj *listPtr,
 	    int *objcPtr, Tcl_Obj ***objvPtr)
 }
-declare 46 generic {
+declare 46 {
     int Tcl_ListObjIndex(Tcl_Interp *interp, Tcl_Obj *listPtr, int index,
 	    Tcl_Obj **objPtrPtr)
 }
-declare 47 generic {
+declare 47 {
     int Tcl_ListObjLength(Tcl_Interp *interp, Tcl_Obj *listPtr,
 	    int *lengthPtr)
 }
-declare 48 generic {
+declare 48 {
     int Tcl_ListObjReplace(Tcl_Interp *interp, Tcl_Obj *listPtr, int first,
 	    int count, int objc, Tcl_Obj *const objv[])
 }
-declare 49 generic {
+declare 49 {
     Tcl_Obj *Tcl_NewBooleanObj(int boolValue)
 }
-declare 50 generic {
+declare 50 {
     Tcl_Obj *Tcl_NewByteArrayObj(const unsigned char *bytes, int length)
 }
-declare 51 generic {
+declare 51 {
     Tcl_Obj *Tcl_NewDoubleObj(double doubleValue)
 }
-declare 52 generic {
+declare 52 {
     Tcl_Obj *Tcl_NewIntObj(int intValue)
 }
-declare 53 generic {
+declare 53 {
     Tcl_Obj *Tcl_NewListObj(int objc, Tcl_Obj *const objv[])
 }
-declare 54 generic {
+declare 54 {
     Tcl_Obj *Tcl_NewLongObj(long longValue)
 }
-declare 55 generic {
+declare 55 {
     Tcl_Obj *Tcl_NewObj(void)
 }
-declare 56 generic {
+declare 56 {
     Tcl_Obj *Tcl_NewStringObj(const char *bytes, int length)
 }
-declare 57 generic {
+declare 57 {
     void Tcl_SetBooleanObj(Tcl_Obj *objPtr, int boolValue)
 }
-declare 58 generic {
+declare 58 {
     unsigned char *Tcl_SetByteArrayLength(Tcl_Obj *objPtr, int length)
 }
-declare 59 generic {
+declare 59 {
     void Tcl_SetByteArrayObj(Tcl_Obj *objPtr, const unsigned char *bytes,
 	    int length)
 }
-declare 60 generic {
+declare 60 {
     void Tcl_SetDoubleObj(Tcl_Obj *objPtr, double doubleValue)
 }
-declare 61 generic {
+declare 61 {
     void Tcl_SetIntObj(Tcl_Obj *objPtr, int intValue)
 }
-declare 62 generic {
+declare 62 {
     void Tcl_SetListObj(Tcl_Obj *objPtr, int objc, Tcl_Obj *const objv[])
 }
-declare 63 generic {
+declare 63 {
     void Tcl_SetLongObj(Tcl_Obj *objPtr, long longValue)
 }
-declare 64 generic {
+declare 64 {
     void Tcl_SetObjLength(Tcl_Obj *objPtr, int length)
 }
-declare 65 generic {
+declare 65 {
     void Tcl_SetStringObj(Tcl_Obj *objPtr, const char *bytes, int length)
 }
-declare 66 generic {
+declare 66 {
     void Tcl_AddErrorInfo(Tcl_Interp *interp, const char *message)
 }
-declare 67 generic {
+declare 67 {
     void Tcl_AddObjErrorInfo(Tcl_Interp *interp, const char *message,
 	    int length)
 }
-declare 68 generic {
+declare 68 {
     void Tcl_AllowExceptions(Tcl_Interp *interp)
 }
-declare 69 generic {
+declare 69 {
     void Tcl_AppendElement(Tcl_Interp *interp, const char *element)
 }
-declare 70 generic {
+declare 70 {
     void Tcl_AppendResult(Tcl_Interp *interp, ...)
 }
-declare 71 generic {
+declare 71 {
     Tcl_AsyncHandler Tcl_AsyncCreate(Tcl_AsyncProc *proc,
 	    ClientData clientData)
 }
-declare 72 generic {
+declare 72 {
     void Tcl_AsyncDelete(Tcl_AsyncHandler async)
 }
-declare 73 generic {
+declare 73 {
     int Tcl_AsyncInvoke(Tcl_Interp *interp, int code)
 }
-declare 74 generic {
+declare 74 {
     void Tcl_AsyncMark(Tcl_AsyncHandler async)
 }
-declare 75 generic {
+declare 75 {
     int Tcl_AsyncReady(void)
 }
-declare 76 generic {
+declare 76 {
     void Tcl_BackgroundError(Tcl_Interp *interp)
 }
-declare 77 generic {
+declare 77 {
     char Tcl_Backslash(const char *src, int *readPtr)
 }
-declare 78 generic {
+declare 78 {
     int Tcl_BadChannelOption(Tcl_Interp *interp, const char *optionName,
 	    const char *optionList)
 }
-declare 79 generic {
+declare 79 {
     void Tcl_CallWhenDeleted(Tcl_Interp *interp, Tcl_InterpDeleteProc *proc,
 	    ClientData clientData)
 }
-declare 80 generic {
+declare 80 {
     void Tcl_CancelIdleCall(Tcl_IdleProc *idleProc, ClientData clientData)
 }
-declare 81 generic {
+declare 81 {
     int Tcl_Close(Tcl_Interp *interp, Tcl_Channel chan)
 }
-declare 82 generic {
+declare 82 {
     int Tcl_CommandComplete(const char *cmd)
 }
-declare 83 generic {
+declare 83 {
     char *Tcl_Concat(int argc, CONST84 char *const *argv)
 }
-declare 84 generic {
+declare 84 {
     int Tcl_ConvertElement(const char *src, char *dst, int flags)
 }
-declare 85 generic {
+declare 85 {
     int Tcl_ConvertCountedElement(const char *src, int length, char *dst,
 	    int flags)
 }
-declare 86 generic {
+declare 86 {
     int Tcl_CreateAlias(Tcl_Interp *slave, const char *slaveCmd,
 	    Tcl_Interp *target, const char *targetCmd, int argc,
 	    CONST84 char *const *argv)
 }
-declare 87 generic {
+declare 87 {
     int Tcl_CreateAliasObj(Tcl_Interp *slave, const char *slaveCmd,
 	    Tcl_Interp *target, const char *targetCmd, int objc,
 	    Tcl_Obj *const objv[])
 }
-declare 88 generic {
+declare 88 {
     Tcl_Channel Tcl_CreateChannel(const Tcl_ChannelType *typePtr,
 	    const char *chanName, ClientData instanceData, int mask)
 }
-declare 89 generic {
+declare 89 {
     void Tcl_CreateChannelHandler(Tcl_Channel chan, int mask,
 	    Tcl_ChannelProc *proc, ClientData clientData)
 }
-declare 90 generic {
+declare 90 {
     void Tcl_CreateCloseHandler(Tcl_Channel chan, Tcl_CloseProc *proc,
 	    ClientData clientData)
 }
-declare 91 generic {
+declare 91 {
     Tcl_Command Tcl_CreateCommand(Tcl_Interp *interp, const char *cmdName,
 	    Tcl_CmdProc *proc, ClientData clientData,
 	    Tcl_CmdDeleteProc *deleteProc)
 }
-declare 92 generic {
+declare 92 {
     void Tcl_CreateEventSource(Tcl_EventSetupProc *setupProc,
 	    Tcl_EventCheckProc *checkProc, ClientData clientData)
 }
-declare 93 generic {
+declare 93 {
     void Tcl_CreateExitHandler(Tcl_ExitProc *proc, ClientData clientData)
 }
-declare 94 generic {
+declare 94 {
     Tcl_Interp *Tcl_CreateInterp(void)
 }
-declare 95 generic {
+declare 95 {
     void Tcl_CreateMathFunc(Tcl_Interp *interp, const char *name,
 	    int numArgs, Tcl_ValueType *argTypes,
 	    Tcl_MathProc *proc, ClientData clientData)
 }
-declare 96 generic {
+declare 96 {
     Tcl_Command Tcl_CreateObjCommand(Tcl_Interp *interp,
 	    const char *cmdName,
 	    Tcl_ObjCmdProc *proc, ClientData clientData,
 	    Tcl_CmdDeleteProc *deleteProc)
 }
-declare 97 generic {
+declare 97 {
     Tcl_Interp *Tcl_CreateSlave(Tcl_Interp *interp, const char *slaveName,
 	    int isSafe)
 }
-declare 98 generic {
+declare 98 {
     Tcl_TimerToken Tcl_CreateTimerHandler(int milliseconds,
 	    Tcl_TimerProc *proc, ClientData clientData)
 }
-declare 99 generic {
+declare 99 {
     Tcl_Trace Tcl_CreateTrace(Tcl_Interp *interp, int level,
 	    Tcl_CmdTraceProc *proc, ClientData clientData)
 }
-declare 100 generic {
+declare 100 {
     void Tcl_DeleteAssocData(Tcl_Interp *interp, const char *name)
 }
-declare 101 generic {
+declare 101 {
     void Tcl_DeleteChannelHandler(Tcl_Channel chan, Tcl_ChannelProc *proc,
 	    ClientData clientData)
 }
-declare 102 generic {
+declare 102 {
     void Tcl_DeleteCloseHandler(Tcl_Channel chan, Tcl_CloseProc *proc,
 	    ClientData clientData)
 }
-declare 103 generic {
+declare 103 {
     int Tcl_DeleteCommand(Tcl_Interp *interp, const char *cmdName)
 }
-declare 104 generic {
+declare 104 {
     int Tcl_DeleteCommandFromToken(Tcl_Interp *interp, Tcl_Command command)
 }
-declare 105 generic {
+declare 105 {
     void Tcl_DeleteEvents(Tcl_EventDeleteProc *proc, ClientData clientData)
 }
-declare 106 generic {
+declare 106 {
     void Tcl_DeleteEventSource(Tcl_EventSetupProc *setupProc,
 	    Tcl_EventCheckProc *checkProc, ClientData clientData)
 }
-declare 107 generic {
+declare 107 {
     void Tcl_DeleteExitHandler(Tcl_ExitProc *proc, ClientData clientData)
 }
-declare 108 generic {
+declare 108 {
     void Tcl_DeleteHashEntry(Tcl_HashEntry *entryPtr)
 }
-declare 109 generic {
+declare 109 {
     void Tcl_DeleteHashTable(Tcl_HashTable *tablePtr)
 }
-declare 110 generic {
+declare 110 {
     void Tcl_DeleteInterp(Tcl_Interp *interp)
 }
-declare 111 generic {
+declare 111 {
     void Tcl_DetachPids(int numPids, Tcl_Pid *pidPtr)
 }
-declare 112 generic {
+declare 112 {
     void Tcl_DeleteTimerHandler(Tcl_TimerToken token)
 }
-declare 113 generic {
+declare 113 {
     void Tcl_DeleteTrace(Tcl_Interp *interp, Tcl_Trace trace)
 }
-declare 114 generic {
+declare 114 {
     void Tcl_DontCallWhenDeleted(Tcl_Interp *interp,
 	    Tcl_InterpDeleteProc *proc, ClientData clientData)
 }
-declare 115 generic {
+declare 115 {
     int Tcl_DoOneEvent(int flags)
 }
-declare 116 generic {
+declare 116 {
     void Tcl_DoWhenIdle(Tcl_IdleProc *proc, ClientData clientData)
 }
-declare 117 generic {
+declare 117 {
     char *Tcl_DStringAppend(Tcl_DString *dsPtr, const char *bytes, int length)
 }
-declare 118 generic {
+declare 118 {
     char *Tcl_DStringAppendElement(Tcl_DString *dsPtr, const char *element)
 }
-declare 119 generic {
+declare 119 {
     void Tcl_DStringEndSublist(Tcl_DString *dsPtr)
 }
-declare 120 generic {
+declare 120 {
     void Tcl_DStringFree(Tcl_DString *dsPtr)
 }
-declare 121 generic {
+declare 121 {
     void Tcl_DStringGetResult(Tcl_Interp *interp, Tcl_DString *dsPtr)
 }
-declare 122 generic {
+declare 122 {
     void Tcl_DStringInit(Tcl_DString *dsPtr)
 }
-declare 123 generic {
+declare 123 {
     void Tcl_DStringResult(Tcl_Interp *interp, Tcl_DString *dsPtr)
 }
-declare 124 generic {
+declare 124 {
     void Tcl_DStringSetLength(Tcl_DString *dsPtr, int length)
 }
-declare 125 generic {
+declare 125 {
     void Tcl_DStringStartSublist(Tcl_DString *dsPtr)
 }
-declare 126 generic {
+declare 126 {
     int Tcl_Eof(Tcl_Channel chan)
 }
-declare 127 generic {
+declare 127 {
     CONST84_RETURN char *Tcl_ErrnoId(void)
 }
-declare 128 generic {
+declare 128 {
     CONST84_RETURN char *Tcl_ErrnoMsg(int err)
 }
-declare 129 generic {
+declare 129 {
     int Tcl_Eval(Tcl_Interp *interp, const char *script)
 }
 # This is obsolete, use Tcl_FSEvalFile
-declare 130 generic {
+declare 130 {
     int Tcl_EvalFile(Tcl_Interp *interp, const char *fileName)
 }
-declare 131 generic {
+declare 131 {
     int Tcl_EvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr)
 }
-declare 132 generic {
+declare 132 {
     void Tcl_EventuallyFree(ClientData clientData, Tcl_FreeProc *freeProc)
 }
-declare 133 generic {
+declare 133 {
     void Tcl_Exit(int status)
 }
-declare 134 generic {
+declare 134 {
     int Tcl_ExposeCommand(Tcl_Interp *interp, const char *hiddenCmdToken,
 	    const char *cmdName)
 }
-declare 135 generic {
+declare 135 {
     int Tcl_ExprBoolean(Tcl_Interp *interp, const char *expr, int *ptr)
 }
-declare 136 generic {
+declare 136 {
     int Tcl_ExprBooleanObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *ptr)
 }
-declare 137 generic {
+declare 137 {
     int Tcl_ExprDouble(Tcl_Interp *interp, const char *expr, double *ptr)
 }
-declare 138 generic {
+declare 138 {
     int Tcl_ExprDoubleObj(Tcl_Interp *interp, Tcl_Obj *objPtr, double *ptr)
 }
-declare 139 generic {
+declare 139 {
     int Tcl_ExprLong(Tcl_Interp *interp, const char *expr, long *ptr)
 }
-declare 140 generic {
+declare 140 {
     int Tcl_ExprLongObj(Tcl_Interp *interp, Tcl_Obj *objPtr, long *ptr)
 }
-declare 141 generic {
+declare 141 {
     int Tcl_ExprObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    Tcl_Obj **resultPtrPtr)
 }
-declare 142 generic {
+declare 142 {
     int Tcl_ExprString(Tcl_Interp *interp, const char *expr)
 }
-declare 143 generic {
+declare 143 {
     void Tcl_Finalize(void)
 }
-declare 144 generic {
+declare 144 {
     void Tcl_FindExecutable(const char *argv0)
 }
-declare 145 generic {
+declare 145 {
     Tcl_HashEntry *Tcl_FirstHashEntry(Tcl_HashTable *tablePtr,
 	    Tcl_HashSearch *searchPtr)
 }
-declare 146 generic {
+declare 146 {
     int Tcl_Flush(Tcl_Channel chan)
 }
-declare 147 generic {
+declare 147 {
     void Tcl_FreeResult(Tcl_Interp *interp)
 }
-declare 148 generic {
+declare 148 {
     int Tcl_GetAlias(Tcl_Interp *interp, const char *slaveCmd,
 	    Tcl_Interp **targetInterpPtr, CONST84 char **targetCmdPtr,
 	    int *argcPtr, CONST84 char ***argvPtr)
 }
-declare 149 generic {
+declare 149 {
     int Tcl_GetAliasObj(Tcl_Interp *interp, const char *slaveCmd,
 	    Tcl_Interp **targetInterpPtr, CONST84 char **targetCmdPtr,
 	    int *objcPtr, Tcl_Obj ***objv)
 }
-declare 150 generic {
+declare 150 {
     ClientData Tcl_GetAssocData(Tcl_Interp *interp, const char *name,
 	    Tcl_InterpDeleteProc **procPtr)
 }
-declare 151 generic {
+declare 151 {
     Tcl_Channel Tcl_GetChannel(Tcl_Interp *interp, const char *chanName,
 	    int *modePtr)
 }
-declare 152 generic {
+declare 152 {
     int Tcl_GetChannelBufferSize(Tcl_Channel chan)
 }
-declare 153 generic {
+declare 153 {
     int Tcl_GetChannelHandle(Tcl_Channel chan, int direction,
 	    ClientData *handlePtr)
 }
-declare 154 generic {
+declare 154 {
     ClientData Tcl_GetChannelInstanceData(Tcl_Channel chan)
 }
-declare 155 generic {
+declare 155 {
     int Tcl_GetChannelMode(Tcl_Channel chan)
 }
-declare 156 generic {
+declare 156 {
     CONST84_RETURN char *Tcl_GetChannelName(Tcl_Channel chan)
 }
-declare 157 generic {
+declare 157 {
     int Tcl_GetChannelOption(Tcl_Interp *interp, Tcl_Channel chan,
 	    const char *optionName, Tcl_DString *dsPtr)
 }
-declare 158 generic {
+declare 158 {
     CONST86 Tcl_ChannelType *Tcl_GetChannelType(Tcl_Channel chan)
 }
-declare 159 generic {
+declare 159 {
     int Tcl_GetCommandInfo(Tcl_Interp *interp, const char *cmdName,
 	    Tcl_CmdInfo *infoPtr)
 }
-declare 160 generic {
+declare 160 {
     CONST84_RETURN char *Tcl_GetCommandName(Tcl_Interp *interp,
 	    Tcl_Command command)
 }
-declare 161 generic {
+declare 161 {
     int Tcl_GetErrno(void)
 }
-declare 162 generic {
+declare 162 {
     CONST84_RETURN char *Tcl_GetHostName(void)
 }
-declare 163 generic {
+declare 163 {
     int Tcl_GetInterpPath(Tcl_Interp *askInterp, Tcl_Interp *slaveInterp)
 }
-declare 164 generic {
+declare 164 {
     Tcl_Interp *Tcl_GetMaster(Tcl_Interp *interp)
 }
-declare 165 generic {
+declare 165 {
     const char *Tcl_GetNameOfExecutable(void)
 }
-declare 166 generic {
+declare 166 {
     Tcl_Obj *Tcl_GetObjResult(Tcl_Interp *interp)
 }
 
 # Tcl_GetOpenFile is only available on unix, but it is a part of the old
-# generic interface, so we inlcude it here for compatibility reasons.
+# interface, so we inlcude it here for compatibility reasons.
 
 declare 167 unix {
     int Tcl_GetOpenFile(Tcl_Interp *interp, const char *chanID, int forWriting,
@@ -605,394 +606,394 @@ declare 167 unix {
 }
 # Obsolete.  Should now use Tcl_FSGetPathType which is objectified
 # and therefore usually faster.
-declare 168 generic {
+declare 168 {
     Tcl_PathType Tcl_GetPathType(const char *path)
 }
-declare 169 generic {
+declare 169 {
     int Tcl_Gets(Tcl_Channel chan, Tcl_DString *dsPtr)
 }
-declare 170 generic {
+declare 170 {
     int Tcl_GetsObj(Tcl_Channel chan, Tcl_Obj *objPtr)
 }
-declare 171 generic {
+declare 171 {
     int Tcl_GetServiceMode(void)
 }
-declare 172 generic {
+declare 172 {
     Tcl_Interp *Tcl_GetSlave(Tcl_Interp *interp, const char *slaveName)
 }
-declare 173 generic {
+declare 173 {
     Tcl_Channel Tcl_GetStdChannel(int type)
 }
-declare 174 generic {
+declare 174 {
     CONST84_RETURN char *Tcl_GetStringResult(Tcl_Interp *interp)
 }
-declare 175 generic {
+declare 175 {
     CONST84_RETURN char *Tcl_GetVar(Tcl_Interp *interp, const char *varName,
 	    int flags)
 }
-declare 176 generic {
+declare 176 {
     CONST84_RETURN char *Tcl_GetVar2(Tcl_Interp *interp, const char *part1,
 	    const char *part2, int flags)
 }
-declare 177 generic {
+declare 177 {
     int Tcl_GlobalEval(Tcl_Interp *interp, const char *command)
 }
-declare 178 generic {
+declare 178 {
     int Tcl_GlobalEvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr)
 }
-declare 179 generic {
+declare 179 {
     int Tcl_HideCommand(Tcl_Interp *interp, const char *cmdName,
 	    const char *hiddenCmdToken)
 }
-declare 180 generic {
+declare 180 {
     int Tcl_Init(Tcl_Interp *interp)
 }
-declare 181 generic {
+declare 181 {
     void Tcl_InitHashTable(Tcl_HashTable *tablePtr, int keyType)
 }
-declare 182 generic {
+declare 182 {
     int Tcl_InputBlocked(Tcl_Channel chan)
 }
-declare 183 generic {
+declare 183 {
     int Tcl_InputBuffered(Tcl_Channel chan)
 }
-declare 184 generic {
+declare 184 {
     int Tcl_InterpDeleted(Tcl_Interp *interp)
 }
-declare 185 generic {
+declare 185 {
     int Tcl_IsSafe(Tcl_Interp *interp)
 }
 # Obsolete, use Tcl_FSJoinPath
-declare 186 generic {
+declare 186 {
     char *Tcl_JoinPath(int argc, CONST84 char *const *argv,
 	    Tcl_DString *resultPtr)
 }
-declare 187 generic {
+declare 187 {
     int Tcl_LinkVar(Tcl_Interp *interp, const char *varName, char *addr,
 	    int type)
 }
 
 # This slot is reserved for use by the plus patch:
-#  declare 188 generic {
+#  declare 188 {
 #	Tcl_MainLoop
 #  }
 
-declare 189 generic {
+declare 189 {
     Tcl_Channel Tcl_MakeFileChannel(ClientData handle, int mode)
 }
-declare 190 generic {
+declare 190 {
     int Tcl_MakeSafe(Tcl_Interp *interp)
 }
-declare 191 generic {
+declare 191 {
     Tcl_Channel Tcl_MakeTcpClientChannel(ClientData tcpSocket)
 }
-declare 192 generic {
+declare 192 {
     char *Tcl_Merge(int argc, CONST84 char *const *argv)
 }
-declare 193 generic {
+declare 193 {
     Tcl_HashEntry *Tcl_NextHashEntry(Tcl_HashSearch *searchPtr)
 }
-declare 194 generic {
+declare 194 {
     void Tcl_NotifyChannel(Tcl_Channel channel, int mask)
 }
-declare 195 generic {
+declare 195 {
     Tcl_Obj *Tcl_ObjGetVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr,
 	    Tcl_Obj *part2Ptr, int flags)
 }
-declare 196 generic {
+declare 196 {
     Tcl_Obj *Tcl_ObjSetVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr,
 	    Tcl_Obj *part2Ptr, Tcl_Obj *newValuePtr, int flags)
 }
-declare 197 generic {
+declare 197 {
     Tcl_Channel Tcl_OpenCommandChannel(Tcl_Interp *interp, int argc,
 	    CONST84 char **argv, int flags)
 }
 # This is obsolete, use Tcl_FSOpenFileChannel
-declare 198 generic {
+declare 198 {
     Tcl_Channel Tcl_OpenFileChannel(Tcl_Interp *interp, const char *fileName,
 	    const char *modeString, int permissions)
 }
-declare 199 generic {
+declare 199 {
     Tcl_Channel Tcl_OpenTcpClient(Tcl_Interp *interp, int port,
 	    const char *address, const char *myaddr, int myport, int async)
 }
-declare 200 generic {
+declare 200 {
     Tcl_Channel Tcl_OpenTcpServer(Tcl_Interp *interp, int port,
 	    const char *host, Tcl_TcpAcceptProc *acceptProc,
 	    ClientData callbackData)
 }
-declare 201 generic {
+declare 201 {
     void Tcl_Preserve(ClientData data)
 }
-declare 202 generic {
+declare 202 {
     void Tcl_PrintDouble(Tcl_Interp *interp, double value, char *dst)
 }
-declare 203 generic {
+declare 203 {
     int Tcl_PutEnv(const char *assignment)
 }
-declare 204 generic {
+declare 204 {
     CONST84_RETURN char *Tcl_PosixError(Tcl_Interp *interp)
 }
-declare 205 generic {
+declare 205 {
     void Tcl_QueueEvent(Tcl_Event *evPtr, Tcl_QueuePosition position)
 }
-declare 206 generic {
+declare 206 {
     int Tcl_Read(Tcl_Channel chan, char *bufPtr, int toRead)
 }
-declare 207 generic {
+declare 207 {
     void Tcl_ReapDetachedProcs(void)
 }
-declare 208 generic {
+declare 208 {
     int Tcl_RecordAndEval(Tcl_Interp *interp, const char *cmd, int flags)
 }
-declare 209 generic {
+declare 209 {
     int Tcl_RecordAndEvalObj(Tcl_Interp *interp, Tcl_Obj *cmdPtr, int flags)
 }
-declare 210 generic {
+declare 210 {
     void Tcl_RegisterChannel(Tcl_Interp *interp, Tcl_Channel chan)
 }
-declare 211 generic {
+declare 211 {
     void Tcl_RegisterObjType(const Tcl_ObjType *typePtr)
 }
-declare 212 generic {
+declare 212 {
     Tcl_RegExp Tcl_RegExpCompile(Tcl_Interp *interp, const char *pattern)
 }
-declare 213 generic {
+declare 213 {
     int Tcl_RegExpExec(Tcl_Interp *interp, Tcl_RegExp regexp,
 	    const char *text, const char *start)
 }
-declare 214 generic {
+declare 214 {
     int Tcl_RegExpMatch(Tcl_Interp *interp, const char *text,
 	    const char *pattern)
 }
-declare 215 generic {
+declare 215 {
     void Tcl_RegExpRange(Tcl_RegExp regexp, int index,
 	    CONST84 char **startPtr, CONST84 char **endPtr)
 }
-declare 216 generic {
+declare 216 {
     void Tcl_Release(ClientData clientData)
 }
-declare 217 generic {
+declare 217 {
     void Tcl_ResetResult(Tcl_Interp *interp)
 }
-declare 218 generic {
+declare 218 {
     int Tcl_ScanElement(const char *str, int *flagPtr)
 }
-declare 219 generic {
+declare 219 {
     int Tcl_ScanCountedElement(const char *str, int length, int *flagPtr)
 }
 # Obsolete
-declare 220 generic {
+declare 220 {
     int Tcl_SeekOld(Tcl_Channel chan, int offset, int mode)
 }
-declare 221 generic {
+declare 221 {
     int Tcl_ServiceAll(void)
 }
-declare 222 generic {
+declare 222 {
     int Tcl_ServiceEvent(int flags)
 }
-declare 223 generic {
+declare 223 {
     void Tcl_SetAssocData(Tcl_Interp *interp, const char *name,
 	    Tcl_InterpDeleteProc *proc, ClientData clientData)
 }
-declare 224 generic {
+declare 224 {
     void Tcl_SetChannelBufferSize(Tcl_Channel chan, int sz)
 }
-declare 225 generic {
+declare 225 {
     int Tcl_SetChannelOption(Tcl_Interp *interp, Tcl_Channel chan,
 	    const char *optionName, const char *newValue)
 }
-declare 226 generic {
+declare 226 {
     int Tcl_SetCommandInfo(Tcl_Interp *interp, const char *cmdName,
 	    const Tcl_CmdInfo *infoPtr)
 }
-declare 227 generic {
+declare 227 {
     void Tcl_SetErrno(int err)
 }
-declare 228 generic {
+declare 228 {
     void Tcl_SetErrorCode(Tcl_Interp *interp, ...)
 }
-declare 229 generic {
+declare 229 {
     void Tcl_SetMaxBlockTime(const Tcl_Time *timePtr)
 }
-declare 230 generic {
+declare 230 {
     void Tcl_SetPanicProc(Tcl_PanicProc *panicProc)
 }
-declare 231 generic {
+declare 231 {
     int Tcl_SetRecursionLimit(Tcl_Interp *interp, int depth)
 }
-declare 232 generic {
+declare 232 {
     void Tcl_SetResult(Tcl_Interp *interp, char *result,
 	    Tcl_FreeProc *freeProc)
 }
-declare 233 generic {
+declare 233 {
     int Tcl_SetServiceMode(int mode)
 }
-declare 234 generic {
+declare 234 {
     void Tcl_SetObjErrorCode(Tcl_Interp *interp, Tcl_Obj *errorObjPtr)
 }
-declare 235 generic {
+declare 235 {
     void Tcl_SetObjResult(Tcl_Interp *interp, Tcl_Obj *resultObjPtr)
 }
-declare 236 generic {
+declare 236 {
     void Tcl_SetStdChannel(Tcl_Channel channel, int type)
 }
-declare 237 generic {
+declare 237 {
     CONST84_RETURN char *Tcl_SetVar(Tcl_Interp *interp, const char *varName,
 	    const char *newValue, int flags)
 }
-declare 238 generic {
+declare 238 {
     CONST84_RETURN char *Tcl_SetVar2(Tcl_Interp *interp, const char *part1,
 	    const char *part2, const char *newValue, int flags)
 }
-declare 239 generic {
+declare 239 {
     CONST84_RETURN char *Tcl_SignalId(int sig)
 }
-declare 240 generic {
+declare 240 {
     CONST84_RETURN char *Tcl_SignalMsg(int sig)
 }
-declare 241 generic {
+declare 241 {
     void Tcl_SourceRCFile(Tcl_Interp *interp)
 }
-declare 242 generic {
+declare 242 {
     int Tcl_SplitList(Tcl_Interp *interp, const char *listStr, int *argcPtr,
 	    CONST84 char ***argvPtr)
 }
 # Obsolete, use Tcl_FSSplitPath
-declare 243 generic {
+declare 243 {
     void Tcl_SplitPath(const char *path, int *argcPtr, CONST84 char ***argvPtr)
 }
-declare 244 generic {
+declare 244 {
     void Tcl_StaticPackage(Tcl_Interp *interp, const char *pkgName,
 	    Tcl_PackageInitProc *initProc, Tcl_PackageInitProc *safeInitProc)
 }
-declare 245 generic {
+declare 245 {
     int Tcl_StringMatch(const char *str, const char *pattern)
 }
 # Obsolete
-declare 246 generic {
+declare 246 {
     int Tcl_TellOld(Tcl_Channel chan)
 }
-declare 247 generic {
+declare 247 {
     int Tcl_TraceVar(Tcl_Interp *interp, const char *varName, int flags,
 	    Tcl_VarTraceProc *proc, ClientData clientData)
 }
-declare 248 generic {
+declare 248 {
     int Tcl_TraceVar2(Tcl_Interp *interp, const char *part1, const char *part2,
 	    int flags, Tcl_VarTraceProc *proc, ClientData clientData)
 }
-declare 249 generic {
+declare 249 {
     char *Tcl_TranslateFileName(Tcl_Interp *interp, const char *name,
 	    Tcl_DString *bufferPtr)
 }
-declare 250 generic {
+declare 250 {
     int Tcl_Ungets(Tcl_Channel chan, const char *str, int len, int atHead)
 }
-declare 251 generic {
+declare 251 {
     void Tcl_UnlinkVar(Tcl_Interp *interp, const char *varName)
 }
-declare 252 generic {
+declare 252 {
     int Tcl_UnregisterChannel(Tcl_Interp *interp, Tcl_Channel chan)
 }
-declare 253 generic {
+declare 253 {
     int Tcl_UnsetVar(Tcl_Interp *interp, const char *varName, int flags)
 }
-declare 254 generic {
+declare 254 {
     int Tcl_UnsetVar2(Tcl_Interp *interp, const char *part1, const char *part2,
 	    int flags)
 }
-declare 255 generic {
+declare 255 {
     void Tcl_UntraceVar(Tcl_Interp *interp, const char *varName, int flags,
 	    Tcl_VarTraceProc *proc, ClientData clientData)
 }
-declare 256 generic {
+declare 256 {
     void Tcl_UntraceVar2(Tcl_Interp *interp, const char *part1,
 	    const char *part2, int flags, Tcl_VarTraceProc *proc,
 	    ClientData clientData)
 }
-declare 257 generic {
+declare 257 {
     void Tcl_UpdateLinkedVar(Tcl_Interp *interp, const char *varName)
 }
-declare 258 generic {
+declare 258 {
     int Tcl_UpVar(Tcl_Interp *interp, const char *frameName,
 	    const char *varName, const char *localName, int flags)
 }
-declare 259 generic {
+declare 259 {
     int Tcl_UpVar2(Tcl_Interp *interp, const char *frameName, const char *part1,
 	    const char *part2, const char *localName, int flags)
 }
-declare 260 generic {
+declare 260 {
     int Tcl_VarEval(Tcl_Interp *interp, ...)
 }
-declare 261 generic {
+declare 261 {
     ClientData Tcl_VarTraceInfo(Tcl_Interp *interp, const char *varName,
 	    int flags, Tcl_VarTraceProc *procPtr, ClientData prevClientData)
 }
-declare 262 generic {
+declare 262 {
     ClientData Tcl_VarTraceInfo2(Tcl_Interp *interp, const char *part1,
 	    const char *part2, int flags, Tcl_VarTraceProc *procPtr,
 	    ClientData prevClientData)
 }
-declare 263 generic {
+declare 263 {
     int Tcl_Write(Tcl_Channel chan, const char *s, int slen)
 }
-declare 264 generic {
+declare 264 {
     void Tcl_WrongNumArgs(Tcl_Interp *interp, int objc,
 	    Tcl_Obj *const objv[], const char *message)
 }
-declare 265 generic {
+declare 265 {
     int Tcl_DumpActiveMemory(const char *fileName)
 }
-declare 266 generic {
+declare 266 {
     void Tcl_ValidateAllMemory(const char *file, int line)
 }
-declare 267 generic {
+declare 267 {
     void Tcl_AppendResultVA(Tcl_Interp *interp, va_list argList)
 }
-declare 268 generic {
+declare 268 {
     void Tcl_AppendStringsToObjVA(Tcl_Obj *objPtr, va_list argList)
 }
-declare 269 generic {
+declare 269 {
     char *Tcl_HashStats(Tcl_HashTable *tablePtr)
 }
-declare 270 generic {
+declare 270 {
     CONST84_RETURN char *Tcl_ParseVar(Tcl_Interp *interp, const char *start,
 	    CONST84 char **termPtr)
 }
-declare 271 generic {
+declare 271 {
     CONST84_RETURN char *Tcl_PkgPresent(Tcl_Interp *interp, const char *name,
 	    const char *version, int exact)
 }
-declare 272 generic {
+declare 272 {
     CONST84_RETURN char *Tcl_PkgPresentEx(Tcl_Interp *interp,
 	    const char *name, const char *version, int exact,
 	    void *clientDataPtr)
 }
-declare 273 generic {
+declare 273 {
     int Tcl_PkgProvide(Tcl_Interp *interp, const char *name,
 	    const char *version)
 }
 # TIP #268: The internally used new Require function is in slot 573.
-declare 274 generic {
+declare 274 {
     CONST84_RETURN char *Tcl_PkgRequire(Tcl_Interp *interp, const char *name,
 	    const char *version, int exact)
 }
-declare 275 generic {
+declare 275 {
     void Tcl_SetErrorCodeVA(Tcl_Interp *interp, va_list argList)
 }
-declare 276 generic {
+declare 276 {
     int  Tcl_VarEvalVA(Tcl_Interp *interp, va_list argList)
 }
-declare 277 generic {
+declare 277 {
     Tcl_Pid Tcl_WaitPid(Tcl_Pid pid, int *statPtr, int options)
 }
-declare 278 generic {
+declare 278 {
     void Tcl_PanicVA(const char *format, va_list argList)
 }
-declare 279 generic {
+declare 279 {
     void Tcl_GetVersion(int *major, int *minor, int *patchLevel, int *type)
 }
-declare 280 generic {
+declare 280 {
     void Tcl_InitMemory(Tcl_Interp *interp)
 }
 
@@ -1010,759 +1011,759 @@ declare 280 generic {
 # (patch usually has no problems to integrate the patch file for the last
 # version into the new one).
 
-declare 281 generic {
+declare 281 {
     Tcl_Channel Tcl_StackChannel(Tcl_Interp *interp,
 	    const Tcl_ChannelType *typePtr, ClientData instanceData,
 	    int mask, Tcl_Channel prevChan)
 }
-declare 282 generic {
+declare 282 {
     int Tcl_UnstackChannel(Tcl_Interp *interp, Tcl_Channel chan)
 }
-declare 283 generic {
+declare 283 {
     Tcl_Channel Tcl_GetStackedChannel(Tcl_Channel chan)
 }
 
 # 284 was reserved, but added in 8.4a2
-declare 284 generic {
+declare 284 {
     void Tcl_SetMainLoop(Tcl_MainLoopProc *proc)
 }
 
 # Reserved for future use (8.0.x vs. 8.1)
-#  declare 285 generic {
+#  declare 285 {
 #  }
 
 # Added in 8.1:
 
-declare 286 generic {
+declare 286 {
     void Tcl_AppendObjToObj(Tcl_Obj *objPtr, Tcl_Obj *appendObjPtr)
 }
-declare 287 generic {
+declare 287 {
     Tcl_Encoding Tcl_CreateEncoding(const Tcl_EncodingType *typePtr)
 }
-declare 288 generic {
+declare 288 {
     void Tcl_CreateThreadExitHandler(Tcl_ExitProc *proc, ClientData clientData)
 }
-declare 289 generic {
+declare 289 {
     void Tcl_DeleteThreadExitHandler(Tcl_ExitProc *proc, ClientData clientData)
 }
-declare 290 generic {
+declare 290 {
     void Tcl_DiscardResult(Tcl_SavedResult *statePtr)
 }
-declare 291 generic {
+declare 291 {
     int Tcl_EvalEx(Tcl_Interp *interp, const char *script, int numBytes,
 	    int flags)
 }
-declare 292 generic {
+declare 292 {
     int Tcl_EvalObjv(Tcl_Interp *interp, int objc, Tcl_Obj *const objv[],
 	    int flags)
 }
-declare 293 generic {
+declare 293 {
     int Tcl_EvalObjEx(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags)
 }
-declare 294 generic {
+declare 294 {
     void Tcl_ExitThread(int status)
 }
-declare 295 generic {
+declare 295 {
     int Tcl_ExternalToUtf(Tcl_Interp *interp, Tcl_Encoding encoding,
 	    const char *src, int srcLen, int flags,
 	    Tcl_EncodingState *statePtr, char *dst, int dstLen,
 	    int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr)
 }
-declare 296 generic {
+declare 296 {
     char *Tcl_ExternalToUtfDString(Tcl_Encoding encoding,
 	    const char *src, int srcLen, Tcl_DString *dsPtr)
 }
-declare 297 generic {
+declare 297 {
     void Tcl_FinalizeThread(void)
 }
-declare 298 generic {
+declare 298 {
     void Tcl_FinalizeNotifier(ClientData clientData)
 }
-declare 299 generic {
+declare 299 {
     void Tcl_FreeEncoding(Tcl_Encoding encoding)
 }
-declare 300 generic {
+declare 300 {
     Tcl_ThreadId Tcl_GetCurrentThread(void)
 }
-declare 301 generic {
+declare 301 {
     Tcl_Encoding Tcl_GetEncoding(Tcl_Interp *interp, const char *name)
 }
-declare 302 generic {
+declare 302 {
     CONST84_RETURN char *Tcl_GetEncodingName(Tcl_Encoding encoding)
 }
-declare 303 generic {
+declare 303 {
     void Tcl_GetEncodingNames(Tcl_Interp *interp)
 }
-declare 304 generic {
+declare 304 {
     int Tcl_GetIndexFromObjStruct(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    const void *tablePtr, int offset, const char *msg, int flags,
 	    int *indexPtr)
 }
-declare 305 generic {
+declare 305 {
     void *Tcl_GetThreadData(Tcl_ThreadDataKey *keyPtr, int size)
 }
-declare 306 generic {
+declare 306 {
     Tcl_Obj *Tcl_GetVar2Ex(Tcl_Interp *interp, const char *part1,
 	    const char *part2, int flags)
 }
-declare 307 generic {
+declare 307 {
     ClientData Tcl_InitNotifier(void)
 }
-declare 308 generic {
+declare 308 {
     void Tcl_MutexLock(Tcl_Mutex *mutexPtr)
 }
-declare 309 generic {
+declare 309 {
     void Tcl_MutexUnlock(Tcl_Mutex *mutexPtr)
 }
-declare 310 generic {
+declare 310 {
     void Tcl_ConditionNotify(Tcl_Condition *condPtr)
 }
-declare 311 generic {
+declare 311 {
     void Tcl_ConditionWait(Tcl_Condition *condPtr, Tcl_Mutex *mutexPtr,
 	    const Tcl_Time *timePtr)
 }
-declare 312 generic {
+declare 312 {
     int Tcl_NumUtfChars(const char *src, int length)
 }
-declare 313 generic {
+declare 313 {
     int Tcl_ReadChars(Tcl_Channel channel, Tcl_Obj *objPtr, int charsToRead,
 	    int appendFlag)
 }
-declare 314 generic {
+declare 314 {
     void Tcl_RestoreResult(Tcl_Interp *interp, Tcl_SavedResult *statePtr)
 }
-declare 315 generic {
+declare 315 {
     void Tcl_SaveResult(Tcl_Interp *interp, Tcl_SavedResult *statePtr)
 }
-declare 316 generic {
+declare 316 {
     int Tcl_SetSystemEncoding(Tcl_Interp *interp, const char *name)
 }
-declare 317 generic {
+declare 317 {
     Tcl_Obj *Tcl_SetVar2Ex(Tcl_Interp *interp, const char *part1,
 	    const char *part2, Tcl_Obj *newValuePtr, int flags)
 }
-declare 318 generic {
+declare 318 {
     void Tcl_ThreadAlert(Tcl_ThreadId threadId)
 }
-declare 319 generic {
+declare 319 {
     void Tcl_ThreadQueueEvent(Tcl_ThreadId threadId, Tcl_Event *evPtr,
 	    Tcl_QueuePosition position)
 }
-declare 320 generic {
+declare 320 {
     Tcl_UniChar Tcl_UniCharAtIndex(const char *src, int index)
 }
-declare 321 generic {
+declare 321 {
     Tcl_UniChar Tcl_UniCharToLower(int ch)
 }
-declare 322 generic {
+declare 322 {
     Tcl_UniChar Tcl_UniCharToTitle(int ch)
 }
-declare 323 generic {
+declare 323 {
     Tcl_UniChar Tcl_UniCharToUpper(int ch)
 }
-declare 324 generic {
+declare 324 {
     int Tcl_UniCharToUtf(int ch, char *buf)
 }
-declare 325 generic {
+declare 325 {
     CONST84_RETURN char *Tcl_UtfAtIndex(const char *src, int index)
 }
-declare 326 generic {
+declare 326 {
     int Tcl_UtfCharComplete(const char *src, int length)
 }
-declare 327 generic {
+declare 327 {
     int Tcl_UtfBackslash(const char *src, int *readPtr, char *dst)
 }
-declare 328 generic {
+declare 328 {
     CONST84_RETURN char *Tcl_UtfFindFirst(const char *src, int ch)
 }
-declare 329 generic {
+declare 329 {
     CONST84_RETURN char *Tcl_UtfFindLast(const char *src, int ch)
 }
-declare 330 generic {
+declare 330 {
     CONST84_RETURN char *Tcl_UtfNext(const char *src)
 }
-declare 331 generic {
+declare 331 {
     CONST84_RETURN char *Tcl_UtfPrev(const char *src, const char *start)
 }
-declare 332 generic {
+declare 332 {
     int Tcl_UtfToExternal(Tcl_Interp *interp, Tcl_Encoding encoding,
 	    const char *src, int srcLen, int flags,
 	    Tcl_EncodingState *statePtr, char *dst, int dstLen,
 	    int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr)
 }
-declare 333 generic {
+declare 333 {
     char *Tcl_UtfToExternalDString(Tcl_Encoding encoding,
 	    const char *src, int srcLen, Tcl_DString *dsPtr)
 }
-declare 334 generic {
+declare 334 {
     int Tcl_UtfToLower(char *src)
 }
-declare 335 generic {
+declare 335 {
     int Tcl_UtfToTitle(char *src)
 }
-declare 336 generic {
+declare 336 {
     int Tcl_UtfToUniChar(const char *src, Tcl_UniChar *chPtr)
 }
-declare 337 generic {
+declare 337 {
     int Tcl_UtfToUpper(char *src)
 }
-declare 338 generic {
+declare 338 {
     int Tcl_WriteChars(Tcl_Channel chan, const char *src, int srcLen)
 }
-declare 339 generic {
+declare 339 {
     int Tcl_WriteObj(Tcl_Channel chan, Tcl_Obj *objPtr)
 }
-declare 340 generic {
+declare 340 {
     char *Tcl_GetString(Tcl_Obj *objPtr)
 }
-declare 341 generic {
+declare 341 {
     CONST84_RETURN char *Tcl_GetDefaultEncodingDir(void)
 }
-declare 342 generic {
+declare 342 {
     void Tcl_SetDefaultEncodingDir(const char *path)
 }
-declare 343 generic {
+declare 343 {
     void Tcl_AlertNotifier(ClientData clientData)
 }
-declare 344 generic {
+declare 344 {
     void Tcl_ServiceModeHook(int mode)
 }
-declare 345 generic {
+declare 345 {
     int Tcl_UniCharIsAlnum(int ch)
 }
-declare 346 generic {
+declare 346 {
     int Tcl_UniCharIsAlpha(int ch)
 }
-declare 347 generic {
+declare 347 {
     int Tcl_UniCharIsDigit(int ch)
 }
-declare 348 generic {
+declare 348 {
     int Tcl_UniCharIsLower(int ch)
 }
-declare 349 generic {
+declare 349 {
     int Tcl_UniCharIsSpace(int ch)
 }
-declare 350 generic {
+declare 350 {
     int Tcl_UniCharIsUpper(int ch)
 }
-declare 351 generic {
+declare 351 {
     int Tcl_UniCharIsWordChar(int ch)
 }
-declare 352 generic {
+declare 352 {
     int Tcl_UniCharLen(const Tcl_UniChar *uniStr)
 }
-declare 353 generic {
+declare 353 {
     int Tcl_UniCharNcmp(const Tcl_UniChar *ucs, const Tcl_UniChar *uct,
 	    unsigned long numChars)
 }
-declare 354 generic {
+declare 354 {
     char *Tcl_UniCharToUtfDString(const Tcl_UniChar *uniStr,
 	    int uniLength, Tcl_DString *dsPtr)
 }
-declare 355 generic {
+declare 355 {
     Tcl_UniChar *Tcl_UtfToUniCharDString(const char *src,
 	    int length, Tcl_DString *dsPtr)
 }
-declare 356 generic {
+declare 356 {
     Tcl_RegExp Tcl_GetRegExpFromObj(Tcl_Interp *interp, Tcl_Obj *patObj,
 	    int flags)
 }
-declare 357 generic {
+declare 357 {
     Tcl_Obj *Tcl_EvalTokens(Tcl_Interp *interp, Tcl_Token *tokenPtr,
 	    int count)
 }
-declare 358 generic {
+declare 358 {
     void Tcl_FreeParse(Tcl_Parse *parsePtr)
 }
-declare 359 generic {
+declare 359 {
     void Tcl_LogCommandInfo(Tcl_Interp *interp, const char *script,
 	    const char *command, int length)
 }
-declare 360 generic {
+declare 360 {
     int Tcl_ParseBraces(Tcl_Interp *interp, const char *start, int numBytes,
 	    Tcl_Parse *parsePtr, int append, CONST84 char **termPtr)
 }
-declare 361 generic {
+declare 361 {
     int Tcl_ParseCommand(Tcl_Interp *interp, const char *start, int numBytes,
 	    int nested, Tcl_Parse *parsePtr)
 }
-declare 362 generic {
+declare 362 {
     int Tcl_ParseExpr(Tcl_Interp *interp, const char *start, int numBytes,
 	    Tcl_Parse *parsePtr)
 }
-declare 363 generic {
+declare 363 {
     int Tcl_ParseQuotedString(Tcl_Interp *interp, const char *start,
 	    int numBytes, Tcl_Parse *parsePtr, int append,
 	    CONST84 char **termPtr)
 }
-declare 364 generic {
+declare 364 {
     int Tcl_ParseVarName(Tcl_Interp *interp, const char *start, int numBytes,
 	    Tcl_Parse *parsePtr, int append)
 }
 # These 4 functions are obsolete, use Tcl_FSGetCwd, Tcl_FSChdir,
 # Tcl_FSAccess and Tcl_FSStat
-declare 365 generic {
+declare 365 {
     char *Tcl_GetCwd(Tcl_Interp *interp, Tcl_DString *cwdPtr)
 }
-declare 366 generic {
+declare 366 {
    int Tcl_Chdir(const char *dirName)
 }
-declare 367 generic {
+declare 367 {
    int Tcl_Access(const char *path, int mode)
 }
-declare 368 generic {
+declare 368 {
     int Tcl_Stat(const char *path, struct stat *bufPtr)
 }
-declare 369 generic {
+declare 369 {
     int Tcl_UtfNcmp(const char *s1, const char *s2, unsigned long n)
 }
-declare 370 generic {
+declare 370 {
     int Tcl_UtfNcasecmp(const char *s1, const char *s2, unsigned long n)
 }
-declare 371 generic {
+declare 371 {
     int Tcl_StringCaseMatch(const char *str, const char *pattern, int nocase)
 }
-declare 372 generic {
+declare 372 {
     int Tcl_UniCharIsControl(int ch)
 }
-declare 373 generic {
+declare 373 {
     int Tcl_UniCharIsGraph(int ch)
 }
-declare 374 generic {
+declare 374 {
     int Tcl_UniCharIsPrint(int ch)
 }
-declare 375 generic {
+declare 375 {
     int Tcl_UniCharIsPunct(int ch)
 }
-declare 376 generic {
+declare 376 {
     int Tcl_RegExpExecObj(Tcl_Interp *interp, Tcl_RegExp regexp,
 	    Tcl_Obj *textObj, int offset, int nmatches, int flags)
 }
-declare 377 generic {
+declare 377 {
     void Tcl_RegExpGetInfo(Tcl_RegExp regexp, Tcl_RegExpInfo *infoPtr)
 }
-declare 378 generic {
+declare 378 {
     Tcl_Obj *Tcl_NewUnicodeObj(const Tcl_UniChar *unicode, int numChars)
 }
-declare 379 generic {
+declare 379 {
     void Tcl_SetUnicodeObj(Tcl_Obj *objPtr, const Tcl_UniChar *unicode,
 	    int numChars)
 }
-declare 380 generic {
+declare 380 {
     int Tcl_GetCharLength(Tcl_Obj *objPtr)
 }
-declare 381 generic {
+declare 381 {
     Tcl_UniChar Tcl_GetUniChar(Tcl_Obj *objPtr, int index)
 }
-declare 382 generic {
+declare 382 {
     Tcl_UniChar *Tcl_GetUnicode(Tcl_Obj *objPtr)
 }
-declare 383 generic {
+declare 383 {
     Tcl_Obj *Tcl_GetRange(Tcl_Obj *objPtr, int first, int last)
 }
-declare 384 generic {
+declare 384 {
     void Tcl_AppendUnicodeToObj(Tcl_Obj *objPtr, const Tcl_UniChar *unicode,
 	    int length)
 }
-declare 385 generic {
+declare 385 {
     int Tcl_RegExpMatchObj(Tcl_Interp *interp, Tcl_Obj *textObj,
 	    Tcl_Obj *patternObj)
 }
-declare 386 generic {
+declare 386 {
     void Tcl_SetNotifier(Tcl_NotifierProcs *notifierProcPtr)
 }
-declare 387 generic {
+declare 387 {
     Tcl_Mutex *Tcl_GetAllocMutex(void)
 }
-declare 388 generic {
+declare 388 {
     int Tcl_GetChannelNames(Tcl_Interp *interp)
 }
-declare 389 generic {
+declare 389 {
     int Tcl_GetChannelNamesEx(Tcl_Interp *interp, const char *pattern)
 }
-declare 390 generic {
+declare 390 {
     int Tcl_ProcObjCmd(ClientData clientData, Tcl_Interp *interp,
 	    int objc, Tcl_Obj *const objv[])
 }
-declare 391 generic {
+declare 391 {
     void Tcl_ConditionFinalize(Tcl_Condition *condPtr)
 }
-declare 392 generic {
+declare 392 {
     void Tcl_MutexFinalize(Tcl_Mutex *mutex)
 }
-declare 393 generic {
+declare 393 {
     int Tcl_CreateThread(Tcl_ThreadId *idPtr, Tcl_ThreadCreateProc *proc,
 	    ClientData clientData, int stackSize, int flags)
 }
 
 # Introduced in 8.3.2
-declare 394 generic {
+declare 394 {
     int Tcl_ReadRaw(Tcl_Channel chan, char *dst, int bytesToRead)
 }
-declare 395 generic {
+declare 395 {
     int Tcl_WriteRaw(Tcl_Channel chan, const char *src, int srcLen)
 }
-declare 396 generic {
+declare 396 {
     Tcl_Channel Tcl_GetTopChannel(Tcl_Channel chan)
 }
-declare 397 generic {
+declare 397 {
     int Tcl_ChannelBuffered(Tcl_Channel chan)
 }
-declare 398 generic {
+declare 398 {
     CONST84_RETURN char *Tcl_ChannelName(const Tcl_ChannelType *chanTypePtr)
 }
-declare 399 generic {
+declare 399 {
     Tcl_ChannelTypeVersion Tcl_ChannelVersion(
 	    const Tcl_ChannelType *chanTypePtr)
 }
-declare 400 generic {
+declare 400 {
     Tcl_DriverBlockModeProc *Tcl_ChannelBlockModeProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
-declare 401 generic {
+declare 401 {
     Tcl_DriverCloseProc *Tcl_ChannelCloseProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
-declare 402 generic {
+declare 402 {
     Tcl_DriverClose2Proc *Tcl_ChannelClose2Proc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
-declare 403 generic {
+declare 403 {
     Tcl_DriverInputProc *Tcl_ChannelInputProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
-declare 404 generic {
+declare 404 {
     Tcl_DriverOutputProc *Tcl_ChannelOutputProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
-declare 405 generic {
+declare 405 {
     Tcl_DriverSeekProc *Tcl_ChannelSeekProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
-declare 406 generic {
+declare 406 {
     Tcl_DriverSetOptionProc *Tcl_ChannelSetOptionProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
-declare 407 generic {
+declare 407 {
     Tcl_DriverGetOptionProc *Tcl_ChannelGetOptionProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
-declare 408 generic {
+declare 408 {
     Tcl_DriverWatchProc *Tcl_ChannelWatchProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
-declare 409 generic {
+declare 409 {
     Tcl_DriverGetHandleProc *Tcl_ChannelGetHandleProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
-declare 410 generic {
+declare 410 {
     Tcl_DriverFlushProc *Tcl_ChannelFlushProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
-declare 411 generic {
+declare 411 {
     Tcl_DriverHandlerProc *Tcl_ChannelHandlerProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
 
 # Introduced in 8.4a2
-declare 412 generic {
+declare 412 {
     int Tcl_JoinThread(Tcl_ThreadId threadId, int *result)
 }
-declare 413 generic {
+declare 413 {
     int Tcl_IsChannelShared(Tcl_Channel channel)
 }
-declare 414 generic {
+declare 414 {
     int Tcl_IsChannelRegistered(Tcl_Interp *interp, Tcl_Channel channel)
 }
-declare 415 generic {
+declare 415 {
     void Tcl_CutChannel(Tcl_Channel channel)
 }
-declare 416 generic {
+declare 416 {
     void Tcl_SpliceChannel(Tcl_Channel channel)
 }
-declare 417 generic {
+declare 417 {
     void Tcl_ClearChannelHandlers(Tcl_Channel channel)
 }
-declare 418 generic {
+declare 418 {
     int Tcl_IsChannelExisting(const char *channelName)
 }
-declare 419 generic {
+declare 419 {
     int Tcl_UniCharNcasecmp(const Tcl_UniChar *ucs, const Tcl_UniChar *uct,
 	    unsigned long numChars)
 }
-declare 420 generic {
+declare 420 {
     int Tcl_UniCharCaseMatch(const Tcl_UniChar *uniStr,
 	    const Tcl_UniChar *uniPattern, int nocase)
 }
-declare 421 generic {
+declare 421 {
     Tcl_HashEntry *Tcl_FindHashEntry(Tcl_HashTable *tablePtr, const void *key)
 }
-declare 422 generic {
+declare 422 {
     Tcl_HashEntry *Tcl_CreateHashEntry(Tcl_HashTable *tablePtr,
 	    const void *key, int *newPtr)
 }
-declare 423 generic {
+declare 423 {
     void Tcl_InitCustomHashTable(Tcl_HashTable *tablePtr, int keyType,
 	    const Tcl_HashKeyType *typePtr)
 }
-declare 424 generic {
+declare 424 {
     void Tcl_InitObjHashTable(Tcl_HashTable *tablePtr)
 }
-declare 425 generic {
+declare 425 {
     ClientData Tcl_CommandTraceInfo(Tcl_Interp *interp, const char *varName,
 	    int flags, Tcl_CommandTraceProc *procPtr,
 	    ClientData prevClientData)
 }
-declare 426 generic {
+declare 426 {
     int Tcl_TraceCommand(Tcl_Interp *interp, const char *varName, int flags,
 	    Tcl_CommandTraceProc *proc, ClientData clientData)
 }
-declare 427 generic {
+declare 427 {
     void Tcl_UntraceCommand(Tcl_Interp *interp, const char *varName,
 	    int flags, Tcl_CommandTraceProc *proc, ClientData clientData)
 }
-declare 428 generic {
+declare 428 {
     char *Tcl_AttemptAlloc(unsigned int size)
 }
-declare 429 generic {
+declare 429 {
     char *Tcl_AttemptDbCkalloc(unsigned int size, const char *file, int line)
 }
-declare 430 generic {
+declare 430 {
     char *Tcl_AttemptRealloc(char *ptr, unsigned int size)
 }
-declare 431 generic {
+declare 431 {
     char *Tcl_AttemptDbCkrealloc(char *ptr, unsigned int size,
 	    const char *file, int line)
 }
-declare 432 generic {
+declare 432 {
     int Tcl_AttemptSetObjLength(Tcl_Obj *objPtr, int length)
 }
 
 # TIP#10 (thread-aware channels) akupries
-declare 433 generic {
+declare 433 {
     Tcl_ThreadId Tcl_GetChannelThread(Tcl_Channel channel)
 }
 
 # introduced in 8.4a3
-declare 434 generic {
+declare 434 {
     Tcl_UniChar *Tcl_GetUnicodeFromObj(Tcl_Obj *objPtr, int *lengthPtr)
 }
 
 # TIP#15 (math function introspection) dkf
-declare 435 generic {
+declare 435 {
     int Tcl_GetMathFuncInfo(Tcl_Interp *interp, const char *name,
 	    int *numArgsPtr, Tcl_ValueType **argTypesPtr,
 	    Tcl_MathProc **procPtr, ClientData *clientDataPtr)
 }
-declare 436 generic {
+declare 436 {
     Tcl_Obj *Tcl_ListMathFuncs(Tcl_Interp *interp, const char *pattern)
 }
 
 # TIP#36 (better access to 'subst') dkf
-declare 437 generic {
+declare 437 {
     Tcl_Obj *Tcl_SubstObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags)
 }
 
 # TIP#17 (virtual filesystem layer) vdarley
-declare 438 generic {
+declare 438 {
     int Tcl_DetachChannel(Tcl_Interp *interp, Tcl_Channel channel)
 }
-declare 439 generic {
+declare 439 {
     int Tcl_IsStandardChannel(Tcl_Channel channel)
 }
-declare 440 generic {
+declare 440 {
     int	Tcl_FSCopyFile(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr)
 }
-declare 441 generic {
+declare 441 {
     int	Tcl_FSCopyDirectory(Tcl_Obj *srcPathPtr,
 	    Tcl_Obj *destPathPtr, Tcl_Obj **errorPtr)
 }
-declare 442 generic {
+declare 442 {
     int	Tcl_FSCreateDirectory(Tcl_Obj *pathPtr)
 }
-declare 443 generic {
+declare 443 {
     int	Tcl_FSDeleteFile(Tcl_Obj *pathPtr)
 }
-declare 444 generic {
+declare 444 {
     int	Tcl_FSLoadFile(Tcl_Interp *interp, Tcl_Obj *pathPtr, const char *sym1,
 	    const char *sym2, Tcl_PackageInitProc **proc1Ptr,
 	    Tcl_PackageInitProc **proc2Ptr, Tcl_LoadHandle *handlePtr,
 	    Tcl_FSUnloadFileProc **unloadProcPtr)
 }
-declare 445 generic {
+declare 445 {
     int	Tcl_FSMatchInDirectory(Tcl_Interp *interp, Tcl_Obj *result,
 	    Tcl_Obj *pathPtr, const char *pattern, Tcl_GlobTypeData *types)
 }
-declare 446 generic {
+declare 446 {
     Tcl_Obj *Tcl_FSLink(Tcl_Obj *pathPtr, Tcl_Obj *toPtr, int linkAction)
 }
-declare 447 generic {
+declare 447 {
     int Tcl_FSRemoveDirectory(Tcl_Obj *pathPtr,
 	    int recursive, Tcl_Obj **errorPtr)
 }
-declare 448 generic {
+declare 448 {
     int	Tcl_FSRenameFile(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr)
 }
-declare 449 generic {
+declare 449 {
     int	Tcl_FSLstat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf)
 }
-declare 450 generic {
+declare 450 {
     int Tcl_FSUtime(Tcl_Obj *pathPtr, struct utimbuf *tval)
 }
-declare 451 generic {
+declare 451 {
     int Tcl_FSFileAttrsGet(Tcl_Interp *interp,
 	    int index, Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef)
 }
-declare 452 generic {
+declare 452 {
     int Tcl_FSFileAttrsSet(Tcl_Interp *interp,
 	    int index, Tcl_Obj *pathPtr, Tcl_Obj *objPtr)
 }
-declare 453 generic {
+declare 453 {
     const char *CONST86 *Tcl_FSFileAttrStrings(Tcl_Obj *pathPtr,
 	    Tcl_Obj **objPtrRef)
 }
-declare 454 generic {
+declare 454 {
     int Tcl_FSStat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf)
 }
-declare 455 generic {
+declare 455 {
     int Tcl_FSAccess(Tcl_Obj *pathPtr, int mode)
 }
-declare 456 generic {
+declare 456 {
     Tcl_Channel Tcl_FSOpenFileChannel(Tcl_Interp *interp, Tcl_Obj *pathPtr,
 	    const char *modeString, int permissions)
 }
-declare 457 generic {
+declare 457 {
     Tcl_Obj *Tcl_FSGetCwd(Tcl_Interp *interp)
 }
-declare 458 generic {
+declare 458 {
     int Tcl_FSChdir(Tcl_Obj *pathPtr)
 }
-declare 459 generic {
+declare 459 {
     int Tcl_FSConvertToPathType(Tcl_Interp *interp, Tcl_Obj *pathPtr)
 }
-declare 460 generic {
+declare 460 {
     Tcl_Obj *Tcl_FSJoinPath(Tcl_Obj *listObj, int elements)
 }
-declare 461 generic {
+declare 461 {
     Tcl_Obj *Tcl_FSSplitPath(Tcl_Obj *pathPtr, int *lenPtr)
 }
-declare 462 generic {
+declare 462 {
     int Tcl_FSEqualPaths(Tcl_Obj *firstPtr, Tcl_Obj *secondPtr)
 }
-declare 463 generic {
+declare 463 {
     Tcl_Obj *Tcl_FSGetNormalizedPath(Tcl_Interp *interp, Tcl_Obj *pathPtr)
 }
-declare 464 generic {
+declare 464 {
     Tcl_Obj *Tcl_FSJoinToPath(Tcl_Obj *pathPtr, int objc,
 	    Tcl_Obj *const objv[])
 }
-declare 465 generic {
+declare 465 {
     ClientData Tcl_FSGetInternalRep(Tcl_Obj *pathPtr,
 	    const Tcl_Filesystem *fsPtr)
 }
-declare 466 generic {
+declare 466 {
     Tcl_Obj *Tcl_FSGetTranslatedPath(Tcl_Interp *interp, Tcl_Obj *pathPtr)
 }
-declare 467 generic {
+declare 467 {
     int Tcl_FSEvalFile(Tcl_Interp *interp, Tcl_Obj *fileName)
 }
-declare 468 generic {
+declare 468 {
     Tcl_Obj *Tcl_FSNewNativePath(const Tcl_Filesystem *fromFilesystem,
 	    ClientData clientData)
 }
-declare 469 generic {
+declare 469 {
     const void *Tcl_FSGetNativePath(Tcl_Obj *pathPtr)
 }
-declare 470 generic {
+declare 470 {
     Tcl_Obj *Tcl_FSFileSystemInfo(Tcl_Obj *pathPtr)
 }
-declare 471 generic {
+declare 471 {
     Tcl_Obj *Tcl_FSPathSeparator(Tcl_Obj *pathPtr)
 }
-declare 472 generic {
+declare 472 {
     Tcl_Obj *Tcl_FSListVolumes(void)
 }
-declare 473 generic {
+declare 473 {
     int Tcl_FSRegister(ClientData clientData, const Tcl_Filesystem *fsPtr)
 }
-declare 474 generic {
+declare 474 {
     int Tcl_FSUnregister(const Tcl_Filesystem *fsPtr)
 }
-declare 475 generic {
+declare 475 {
     ClientData Tcl_FSData(const Tcl_Filesystem *fsPtr)
 }
-declare 476 generic {
+declare 476 {
     const char *Tcl_FSGetTranslatedStringPath(Tcl_Interp *interp,
 	    Tcl_Obj *pathPtr)
 }
-declare 477 generic {
+declare 477 {
     CONST86 Tcl_Filesystem *Tcl_FSGetFileSystemForPath(Tcl_Obj *pathPtr)
 }
-declare 478 generic {
+declare 478 {
     Tcl_PathType Tcl_FSGetPathType(Tcl_Obj *pathPtr)
 }
 
 # TIP#49 (detection of output buffering) akupries
-declare 479 generic {
+declare 479 {
     int Tcl_OutputBuffered(Tcl_Channel chan)
 }
-declare 480 generic {
+declare 480 {
     void Tcl_FSMountsChanged(const Tcl_Filesystem *fsPtr)
 }
 
 # TIP#56 (evaluate a parsed script) msofer
-declare 481 generic {
+declare 481 {
     int Tcl_EvalTokensStandard(Tcl_Interp *interp, Tcl_Token *tokenPtr,
 	    int count)
 }
 
 # TIP#73 (access to current time) kbk
-declare 482 generic {
+declare 482 {
     void Tcl_GetTime(Tcl_Time *timeBuf)
 }
 
 # TIP#32 (object-enabled traces) kbk
-declare 483 generic {
+declare 483 {
     Tcl_Trace Tcl_CreateObjTrace(Tcl_Interp *interp, int level, int flags,
 	    Tcl_CmdObjTraceProc *objProc, ClientData clientData,
 	    Tcl_CmdObjTraceDeleteProc *delProc)
 }
-declare 484 generic {
+declare 484 {
     int Tcl_GetCommandInfoFromToken(Tcl_Command token, Tcl_CmdInfo *infoPtr)
 }
-declare 485 generic {
+declare 485 {
     int Tcl_SetCommandInfoFromToken(Tcl_Command token,
 	    const Tcl_CmdInfo *infoPtr)
 }
 
 ### New functions on 64-bit dev branch ###
 # TIP#72 (64-bit values) dkf
-declare 486 generic {
+declare 486 {
     Tcl_Obj *Tcl_DbNewWideIntObj(Tcl_WideInt wideValue,
 	    const char *file, int line)
 }
-declare 487 generic {
+declare 487 {
     int Tcl_GetWideIntFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    Tcl_WideInt *widePtr)
 }
-declare 488 generic {
+declare 488 {
     Tcl_Obj *Tcl_NewWideIntObj(Tcl_WideInt wideValue)
 }
-declare 489 generic {
+declare 489 {
     void Tcl_SetWideIntObj(Tcl_Obj *objPtr, Tcl_WideInt wideValue)
 }
-declare 490 generic {
+declare 490 {
     Tcl_StatBuf *Tcl_AllocStatBuf(void)
 }
-declare 491 generic {
+declare 491 {
     Tcl_WideInt Tcl_Seek(Tcl_Channel chan, Tcl_WideInt offset, int mode)
 }
-declare 492 generic {
+declare 492 {
     Tcl_WideInt Tcl_Tell(Tcl_Channel chan)
 }
 
 # TIP#91 (back-compat enhancements for channels) dkf
-declare 493 generic {
+declare 493 {
     Tcl_DriverWideSeekProc *Tcl_ChannelWideSeekProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
@@ -1770,552 +1771,552 @@ declare 493 generic {
 # ----- BASELINE -- FOR -- 8.4.0 ----- #
 
 # TIP#111 (dictionaries) dkf
-declare 494 generic {
+declare 494 {
     int Tcl_DictObjPut(Tcl_Interp *interp, Tcl_Obj *dictPtr,
 	    Tcl_Obj *keyPtr, Tcl_Obj *valuePtr)
 }
-declare 495 generic {
+declare 495 {
     int Tcl_DictObjGet(Tcl_Interp *interp, Tcl_Obj *dictPtr, Tcl_Obj *keyPtr,
 	    Tcl_Obj **valuePtrPtr)
 }
-declare 496 generic {
+declare 496 {
     int Tcl_DictObjRemove(Tcl_Interp *interp, Tcl_Obj *dictPtr,
 	    Tcl_Obj *keyPtr)
 }
-declare 497 generic {
+declare 497 {
     int Tcl_DictObjSize(Tcl_Interp *interp, Tcl_Obj *dictPtr, int *sizePtr)
 }
-declare 498 generic {
+declare 498 {
     int Tcl_DictObjFirst(Tcl_Interp *interp, Tcl_Obj *dictPtr,
 	    Tcl_DictSearch *searchPtr,
 	    Tcl_Obj **keyPtrPtr, Tcl_Obj **valuePtrPtr, int *donePtr)
 }
-declare 499 generic {
+declare 499 {
     void Tcl_DictObjNext(Tcl_DictSearch *searchPtr,
 	    Tcl_Obj **keyPtrPtr, Tcl_Obj **valuePtrPtr, int *donePtr)
 }
-declare 500 generic {
+declare 500 {
     void Tcl_DictObjDone(Tcl_DictSearch *searchPtr)
 }
-declare 501 generic {
+declare 501 {
     int Tcl_DictObjPutKeyList(Tcl_Interp *interp, Tcl_Obj *dictPtr,
 	    int keyc, Tcl_Obj *const *keyv, Tcl_Obj *valuePtr)
 }
-declare 502 generic {
+declare 502 {
     int Tcl_DictObjRemoveKeyList(Tcl_Interp *interp, Tcl_Obj *dictPtr,
 	    int keyc, Tcl_Obj *const *keyv)
 }
-declare 503 generic {
+declare 503 {
     Tcl_Obj *Tcl_NewDictObj(void)
 }
-declare 504 generic {
+declare 504 {
     Tcl_Obj *Tcl_DbNewDictObj(const char *file, int line)
 }
 
 # TIP#59 (configuration reporting) akupries
-declare 505 generic {
+declare 505 {
     void Tcl_RegisterConfig(Tcl_Interp *interp, const char *pkgName,
 	    const Tcl_Config *configuration, const char *valEncoding)
 }
 
 # TIP #139 (partial exposure of namespace API - transferred from tclInt.decls)
 # dkf, API by Brent Welch?
-declare 506 generic {
+declare 506 {
     Tcl_Namespace *Tcl_CreateNamespace(Tcl_Interp *interp, const char *name,
 	    ClientData clientData, Tcl_NamespaceDeleteProc *deleteProc)
 }
-declare 507 generic {
+declare 507 {
     void Tcl_DeleteNamespace(Tcl_Namespace *nsPtr)
 }
-declare 508 generic {
+declare 508 {
     int Tcl_AppendExportList(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
 	    Tcl_Obj *objPtr)
 }
-declare 509 generic {
+declare 509 {
     int Tcl_Export(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
 	    const char *pattern, int resetListFirst)
 }
-declare 510 generic {
+declare 510 {
     int Tcl_Import(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
 	    const char *pattern, int allowOverwrite)
 }
-declare 511 generic {
+declare 511 {
     int Tcl_ForgetImport(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
 	    const char *pattern)
 }
-declare 512 generic {
+declare 512 {
     Tcl_Namespace *Tcl_GetCurrentNamespace(Tcl_Interp *interp)
 }
-declare 513 generic {
+declare 513 {
     Tcl_Namespace *Tcl_GetGlobalNamespace(Tcl_Interp *interp)
 }
-declare 514 generic {
+declare 514 {
     Tcl_Namespace *Tcl_FindNamespace(Tcl_Interp *interp, const char *name,
 	    Tcl_Namespace *contextNsPtr, int flags)
 }
-declare 515 generic {
+declare 515 {
     Tcl_Command Tcl_FindCommand(Tcl_Interp *interp, const char *name,
 	    Tcl_Namespace *contextNsPtr, int flags)
 }
-declare 516 generic {
+declare 516 {
     Tcl_Command Tcl_GetCommandFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr)
 }
-declare 517 generic {
+declare 517 {
     void Tcl_GetCommandFullName(Tcl_Interp *interp, Tcl_Command command,
 	    Tcl_Obj *objPtr)
 }
 
 # TIP#137 (encoding-aware source command) dgp for Anton Kovalenko
-declare 518 generic {
+declare 518 {
     int Tcl_FSEvalFileEx(Tcl_Interp *interp, Tcl_Obj *fileName,
 	    const char *encodingName)
 }
 
 # TIP#121 (exit handler) dkf for Joe Mistachkin
-declare 519 generic {
+declare 519 {
     Tcl_ExitProc *Tcl_SetExitProc(Tcl_ExitProc *proc)
 }
 
 # TIP#143 (resource limits) dkf
-declare 520 generic {
+declare 520 {
     void Tcl_LimitAddHandler(Tcl_Interp *interp, int type,
 	    Tcl_LimitHandlerProc *handlerProc, ClientData clientData,
 	    Tcl_LimitHandlerDeleteProc *deleteProc)
 }
-declare 521 generic {
+declare 521 {
     void Tcl_LimitRemoveHandler(Tcl_Interp *interp, int type,
 	    Tcl_LimitHandlerProc *handlerProc, ClientData clientData)
 }
-declare 522 generic {
+declare 522 {
     int Tcl_LimitReady(Tcl_Interp *interp)
 }
-declare 523 generic {
+declare 523 {
     int Tcl_LimitCheck(Tcl_Interp *interp)
 }
-declare 524 generic {
+declare 524 {
     int Tcl_LimitExceeded(Tcl_Interp *interp)
 }
-declare 525 generic {
+declare 525 {
     void Tcl_LimitSetCommands(Tcl_Interp *interp, int commandLimit)
 }
-declare 526 generic {
+declare 526 {
     void Tcl_LimitSetTime(Tcl_Interp *interp, Tcl_Time *timeLimitPtr)
 }
-declare 527 generic {
+declare 527 {
     void Tcl_LimitSetGranularity(Tcl_Interp *interp, int type, int granularity)
 }
-declare 528 generic {
+declare 528 {
     int Tcl_LimitTypeEnabled(Tcl_Interp *interp, int type)
 }
-declare 529 generic {
+declare 529 {
     int Tcl_LimitTypeExceeded(Tcl_Interp *interp, int type)
 }
-declare 530 generic {
+declare 530 {
     void Tcl_LimitTypeSet(Tcl_Interp *interp, int type)
 }
-declare 531 generic {
+declare 531 {
     void Tcl_LimitTypeReset(Tcl_Interp *interp, int type)
 }
-declare 532 generic {
+declare 532 {
     int Tcl_LimitGetCommands(Tcl_Interp *interp)
 }
-declare 533 generic {
+declare 533 {
     void Tcl_LimitGetTime(Tcl_Interp *interp, Tcl_Time *timeLimitPtr)
 }
-declare 534 generic {
+declare 534 {
     int Tcl_LimitGetGranularity(Tcl_Interp *interp, int type)
 }
 
 # TIP#226 (interpreter result state management) dgp
-declare 535 generic {
+declare 535 {
     Tcl_InterpState Tcl_SaveInterpState(Tcl_Interp *interp, int status)
 }
-declare 536 generic {
+declare 536 {
     int Tcl_RestoreInterpState(Tcl_Interp *interp, Tcl_InterpState state)
 }
-declare 537 generic {
+declare 537 {
     void Tcl_DiscardInterpState(Tcl_InterpState state)
 }
 
 # TIP#227 (return options interface) dgp
-declare 538 generic {
+declare 538 {
     int Tcl_SetReturnOptions(Tcl_Interp *interp, Tcl_Obj *options)
 }
-declare 539 generic {
+declare 539 {
     Tcl_Obj *Tcl_GetReturnOptions(Tcl_Interp *interp, int result)
 }
 
 # TIP#235 (ensembles) dkf
-declare 540 generic {
+declare 540 {
     int Tcl_IsEnsemble(Tcl_Command token)
 }
-declare 541 generic {
+declare 541 {
     Tcl_Command Tcl_CreateEnsemble(Tcl_Interp *interp, const char *name,
 	    Tcl_Namespace *namespacePtr, int flags)
 }
-declare 542 generic {
+declare 542 {
     Tcl_Command Tcl_FindEnsemble(Tcl_Interp *interp, Tcl_Obj *cmdNameObj,
 	    int flags)
 }
-declare 543 generic {
+declare 543 {
     int Tcl_SetEnsembleSubcommandList(Tcl_Interp *interp, Tcl_Command token,
 	    Tcl_Obj *subcmdList)
 }
-declare 544 generic {
+declare 544 {
     int Tcl_SetEnsembleMappingDict(Tcl_Interp *interp, Tcl_Command token,
 	    Tcl_Obj *mapDict)
 }
-declare 545 generic {
+declare 545 {
     int Tcl_SetEnsembleUnknownHandler(Tcl_Interp *interp, Tcl_Command token,
 	    Tcl_Obj *unknownList)
 }
-declare 546 generic {
+declare 546 {
     int Tcl_SetEnsembleFlags(Tcl_Interp *interp, Tcl_Command token, int flags)
 }
-declare 547 generic {
+declare 547 {
     int Tcl_GetEnsembleSubcommandList(Tcl_Interp *interp, Tcl_Command token,
 	    Tcl_Obj **subcmdListPtr)
 }
-declare 548 generic {
+declare 548 {
     int Tcl_GetEnsembleMappingDict(Tcl_Interp *interp, Tcl_Command token,
 	    Tcl_Obj **mapDictPtr)
 }
-declare 549 generic {
+declare 549 {
     int Tcl_GetEnsembleUnknownHandler(Tcl_Interp *interp, Tcl_Command token,
 	    Tcl_Obj **unknownListPtr)
 }
-declare 550 generic {
+declare 550 {
     int Tcl_GetEnsembleFlags(Tcl_Interp *interp, Tcl_Command token,
 	    int *flagsPtr)
 }
-declare 551 generic {
+declare 551 {
     int Tcl_GetEnsembleNamespace(Tcl_Interp *interp, Tcl_Command token,
 	    Tcl_Namespace **namespacePtrPtr)
 }
 
 # TIP#233 (virtualized time) akupries
-declare 552 generic {
+declare 552 {
     void Tcl_SetTimeProc(Tcl_GetTimeProc *getProc,
 	    Tcl_ScaleTimeProc *scaleProc,
 	    ClientData clientData)
 }
-declare 553 generic {
+declare 553 {
     void Tcl_QueryTimeProc(Tcl_GetTimeProc **getProc,
 	    Tcl_ScaleTimeProc **scaleProc,
 	    ClientData *clientData)
 }
 
 # TIP#218 (driver thread actions) davygrvy/akupries ChannelType ver 4
-declare 554 generic {
+declare 554 {
     Tcl_DriverThreadActionProc *Tcl_ChannelThreadActionProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
 
 # TIP#237 (arbitrary-precision integers) kbk
-declare 555 generic {
+declare 555 {
     Tcl_Obj *Tcl_NewBignumObj(mp_int *value)
 }
-declare 556 generic {
+declare 556 {
     Tcl_Obj *Tcl_DbNewBignumObj(mp_int *value, const char *file, int line)
 }
-declare 557 generic {
+declare 557 {
     void Tcl_SetBignumObj(Tcl_Obj *obj, mp_int *value)
 }
-declare 558 generic {
+declare 558 {
     int Tcl_GetBignumFromObj(Tcl_Interp *interp, Tcl_Obj *obj, mp_int *value)
 }
-declare 559 generic {
+declare 559 {
     int Tcl_TakeBignumFromObj(Tcl_Interp *interp, Tcl_Obj *obj, mp_int *value)
 }
 
 # TIP #208 ('chan' command) jeffh
-declare 560 generic {
+declare 560 {
     int Tcl_TruncateChannel(Tcl_Channel chan, Tcl_WideInt length)
 }
-declare 561 generic {
+declare 561 {
     Tcl_DriverTruncateProc *Tcl_ChannelTruncateProc(
 	    const Tcl_ChannelType *chanTypePtr)
 }
 
 # TIP#219 (channel reflection api) akupries
-declare 562 generic {
+declare 562 {
     void Tcl_SetChannelErrorInterp(Tcl_Interp *interp, Tcl_Obj *msg)
 }
-declare 563 generic {
+declare 563 {
     void Tcl_GetChannelErrorInterp(Tcl_Interp *interp, Tcl_Obj **msg)
 }
-declare 564 generic {
+declare 564 {
     void Tcl_SetChannelError(Tcl_Channel chan, Tcl_Obj *msg)
 }
-declare 565 generic {
+declare 565 {
     void Tcl_GetChannelError(Tcl_Channel chan, Tcl_Obj **msg)
 }
 
 # TIP #237 (additional conversion functions for bignum support) kbk/dgp
-declare 566 generic {
+declare 566 {
     int Tcl_InitBignumFromDouble(Tcl_Interp *interp, double initval,
 	    mp_int *toInit)
 }
 
 # TIP#181 (namespace unknown command) dgp for Neil Madden
-declare 567 generic {
+declare 567 {
     Tcl_Obj *Tcl_GetNamespaceUnknownHandler(Tcl_Interp *interp,
 	    Tcl_Namespace *nsPtr)
 }
-declare 568 generic {
+declare 568 {
     int Tcl_SetNamespaceUnknownHandler(Tcl_Interp *interp,
 	    Tcl_Namespace *nsPtr, Tcl_Obj *handlerPtr)
 }
 
 # TIP#258 (enhanced interface for encodings) dgp
-declare 569 generic {
+declare 569 {
     int Tcl_GetEncodingFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    Tcl_Encoding *encodingPtr)
 }
-declare 570 generic {
+declare 570 {
     Tcl_Obj *Tcl_GetEncodingSearchPath(void)
 }
-declare 571 generic {
+declare 571 {
     int Tcl_SetEncodingSearchPath(Tcl_Obj *searchPath)
 }
-declare 572 generic {
+declare 572 {
     const char *Tcl_GetEncodingNameFromEnvironment(Tcl_DString *bufPtr)
 }
 
 # TIP#268 (extended version numbers and requirements) akupries
-declare 573 generic {
+declare 573 {
     int Tcl_PkgRequireProc(Tcl_Interp *interp, const char *name,
 	    int objc, Tcl_Obj *const objv[], void *clientDataPtr)
 }
 
 # TIP#270 (utility C routines for string formatting) dgp
-declare 574 generic {
+declare 574 {
     void Tcl_AppendObjToErrorInfo(Tcl_Interp *interp, Tcl_Obj *objPtr)
 }
-declare 575 generic {
+declare 575 {
     void Tcl_AppendLimitedToObj(Tcl_Obj *objPtr, const char *bytes, int length,
 	    int limit, const char *ellipsis)
 }
-declare 576 generic {
+declare 576 {
     Tcl_Obj *Tcl_Format(Tcl_Interp *interp, const char *format, int objc,
 	    Tcl_Obj *const objv[])
 }
-declare 577 generic {
+declare 577 {
     int Tcl_AppendFormatToObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    const char *format, int objc, Tcl_Obj *const objv[])
 }
-declare 578 generic {
+declare 578 {
     Tcl_Obj *Tcl_ObjPrintf(const char *format, ...)
 }
-declare 579 generic {
+declare 579 {
     void Tcl_AppendPrintfToObj(Tcl_Obj *objPtr, const char *format, ...)
 }
 
 # ----- BASELINE -- FOR -- 8.5.0 ----- #
 
 # TIP #285 (script cancellation support) jmistachkin
-declare 580 generic {
+declare 580 {
     int Tcl_CancelEval(Tcl_Interp *interp, Tcl_Obj *resultObjPtr,
 	    ClientData clientData, int flags)
 }
-declare 581 generic {
+declare 581 {
     int Tcl_Canceled(Tcl_Interp *interp, int flags)
 }
 
 # TIP#304 (chan pipe) aferrieux
-declare 582 generic {
+declare 582 {
     int Tcl_CreatePipe(Tcl_Interp  *interp, Tcl_Channel *rchan,
 	    Tcl_Channel *wchan, int flags)
 }
 
 # TIP #322 (NRE public interface) msofer
-declare 583 generic {
+declare 583 {
     Tcl_Command Tcl_NRCreateCommand(Tcl_Interp *interp,
 	    const char *cmdName, Tcl_ObjCmdProc *proc,
 	    Tcl_ObjCmdProc *nreProc, ClientData clientData,
 	    Tcl_CmdDeleteProc *deleteProc)
 }
-declare 584 generic {
+declare 584 {
     int Tcl_NREvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags)
 }
-declare 585 generic {
+declare 585 {
     int Tcl_NREvalObjv(Tcl_Interp *interp, int objc, Tcl_Obj *const objv[],
 	    int flags)
 }
-declare 586 generic {
+declare 586 {
     int Tcl_NRCmdSwap(Tcl_Interp *interp, Tcl_Command cmd, int objc,
 	    Tcl_Obj *const objv[], int flags)
 }
-declare 587 generic {
+declare 587 {
     void Tcl_NRAddCallback(Tcl_Interp *interp, Tcl_NRPostProc *postProcPtr,
 	    ClientData data0, ClientData data1, ClientData data2,
 	    ClientData data3)
 }
 # For use by NR extenders, to have a simple way to also provide a (required!)
 # classic objProc
-declare 588 generic {
+declare 588 {
     int Tcl_NRCallObjProc(Tcl_Interp *interp, Tcl_ObjCmdProc *objProc,
 	    ClientData clientData, int objc, Tcl_Obj *const objv[])
 }
 
 # TIP#316 (Tcl_StatBuf reader functions) dkf
-declare 589 generic {
+declare 589 {
     unsigned Tcl_GetFSDeviceFromStat(const Tcl_StatBuf *statPtr)
 }
-declare 590 generic {
+declare 590 {
     unsigned Tcl_GetFSInodeFromStat(const Tcl_StatBuf *statPtr)
 }
-declare 591 generic {
+declare 591 {
     unsigned Tcl_GetModeFromStat(const Tcl_StatBuf *statPtr)
 }
-declare 592 generic {
+declare 592 {
     int Tcl_GetLinkCountFromStat(const Tcl_StatBuf *statPtr)
 }
-declare 593 generic {
+declare 593 {
     int Tcl_GetUserIdFromStat(const Tcl_StatBuf *statPtr)
 }
-declare 594 generic {
+declare 594 {
     int Tcl_GetGroupIdFromStat(const Tcl_StatBuf *statPtr)
 }
-declare 595 generic {
+declare 595 {
     int Tcl_GetDeviceTypeFromStat(const Tcl_StatBuf *statPtr)
 }
-declare 596 generic {
+declare 596 {
     Tcl_WideInt Tcl_GetAccessTimeFromStat(const Tcl_StatBuf *statPtr)
 }
-declare 597 generic {
+declare 597 {
     Tcl_WideInt Tcl_GetModificationTimeFromStat(const Tcl_StatBuf *statPtr)
 }
-declare 598 generic {
+declare 598 {
     Tcl_WideInt Tcl_GetChangeTimeFromStat(const Tcl_StatBuf *statPtr)
 }
-declare 599 generic {
+declare 599 {
     Tcl_WideUInt Tcl_GetSizeFromStat(const Tcl_StatBuf *statPtr)
 }
-declare 600 generic {
+declare 600 {
     Tcl_WideUInt Tcl_GetBlocksFromStat(const Tcl_StatBuf *statPtr)
 }
-declare 601 generic {
+declare 601 {
     unsigned Tcl_GetBlockSizeFromStat(const Tcl_StatBuf *statPtr)
 }
 
 # TIP#314 (ensembles with parameters) dkf for Lars Hellstr"om
-declare 602 generic {
+declare 602 {
     int Tcl_SetEnsembleParameterList(Tcl_Interp *interp, Tcl_Command token,
 	    Tcl_Obj *paramList)
 }
-declare 603 generic {
+declare 603 {
     int Tcl_GetEnsembleParameterList(Tcl_Interp *interp, Tcl_Command token,
 	    Tcl_Obj **paramListPtr)
 }
 
 # TIP#265 (option parser) dkf for Sam Bromley
-declare 604 generic {
+declare 604 {
     int Tcl_ParseArgsObjv(Tcl_Interp *interp, const Tcl_ArgvInfo *argTable,
 	    int *objcPtr, Tcl_Obj *const *objv, Tcl_Obj ***remObjv)
 }
 
 # TIP#336 (manipulate the error line) dgp
-declare 605 generic {
+declare 605 {
     int Tcl_GetErrorLine(Tcl_Interp *interp)
 }
-declare 606 generic {
+declare 606 {
     void Tcl_SetErrorLine(Tcl_Interp *interp, int lineNum)
 }
 
 # TIP#307 (move results between interpreters) dkf
-declare 607 generic {
+declare 607 {
     void Tcl_TransferResult(Tcl_Interp *sourceInterp, int result,
 	    Tcl_Interp *targetInterp)
 }
 
 # TIP#335 (detect if interpreter in use) jmistachkin
-declare 608 generic {
+declare 608 {
     int Tcl_InterpActive(Tcl_Interp *interp)
 }
 
 # TIP#337 (log exception for background processing) dgp
-declare 609 generic {
+declare 609 {
     void Tcl_BackgroundException(Tcl_Interp *interp, int code)
 }
 
 # TIP#234 (zlib interface) dkf/Pascal Scheffers
-declare 610 generic {
+declare 610 {
     int Tcl_ZlibDeflate(Tcl_Interp *interp, int format, Tcl_Obj *data,
 	    int level, Tcl_Obj *gzipHeaderDictObj)
 }
-declare 611 generic {
+declare 611 {
     int Tcl_ZlibInflate(Tcl_Interp *interp, int format, Tcl_Obj *data,
 	    int buffersize, Tcl_Obj *gzipHeaderDictObj)
 }
-declare 612 generic {
+declare 612 {
     unsigned int Tcl_ZlibCRC32(unsigned int crc, const unsigned char *buf,
 	    int len)
 }
-declare 613 generic {
+declare 613 {
     unsigned int Tcl_ZlibAdler32(unsigned int adler, const unsigned char *buf,
 	    int len)
 }
-declare 614 generic {
+declare 614 {
     int Tcl_ZlibStreamInit(Tcl_Interp *interp, int mode, int format,
 	    int level, Tcl_Obj *dictObj, Tcl_ZlibStream *zshandle)
 }
-declare 615 generic {
+declare 615 {
     Tcl_Obj *Tcl_ZlibStreamGetCommandName(Tcl_ZlibStream zshandle)
 }
-declare 616 generic {
+declare 616 {
     int Tcl_ZlibStreamEof(Tcl_ZlibStream zshandle)
 }
-declare 617 generic {
+declare 617 {
     int Tcl_ZlibStreamChecksum(Tcl_ZlibStream zshandle)
 }
-declare 618 generic {
+declare 618 {
     int Tcl_ZlibStreamPut(Tcl_ZlibStream zshandle, Tcl_Obj *data, int flush)
 }
-declare 619 generic {
+declare 619 {
     int Tcl_ZlibStreamGet(Tcl_ZlibStream zshandle, Tcl_Obj *data, int count)
 }
-declare 620 generic {
+declare 620 {
     int Tcl_ZlibStreamClose(Tcl_ZlibStream zshandle)
 }
-declare 621 generic {
+declare 621 {
     int Tcl_ZlibStreamReset(Tcl_ZlibStream zshandle)
 }
 
 # TIP 338 (control over startup script) dgp
-declare 622 generic {
+declare 622 {
     void Tcl_SetStartupScript(Tcl_Obj *path, const char *encoding)
 }
-declare 623 generic {
+declare 623 {
     Tcl_Obj *Tcl_GetStartupScript(const char **encodingPtr)
 }
 
 # TIP#332 (half-close made public) aferrieux
-declare 624 generic {
+declare 624 {
     int Tcl_CloseEx(Tcl_Interp *interp, Tcl_Channel chan, int flags)
 }
 
 # TIP #353 (NR-enabled expressions) dgp
-declare 625 generic {
+declare 625 {
     int Tcl_NRExprObj(Tcl_Interp *interp, Tcl_Obj *objPtr, Tcl_Obj *resultPtr)
 }
 
 # TIP #356 (NR-enabled substitution) dgp
-declare 626 generic {
+declare 626 {
     int Tcl_NRSubstObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags)
 }
 
 # TIP #357 (Export TclLoadFile and TclpFindSymbol) kbk
-declare 627 generic {
+declare 627 {
     int Tcl_LoadFile(Tcl_Interp *interp, Tcl_Obj *pathPtr,
 		     const char *const symv[], int flags, void *procPtrs,
 		     Tcl_LoadHandle *handlePtr)
 }
-declare 628 generic {
+declare 628 {
     void* Tcl_FindSymbol(Tcl_Interp *interp, Tcl_LoadHandle handle,
 			 const char *symbol)
 }
-declare 629 generic {
+declare 629 {
     int Tcl_FSUnloadFile(Tcl_Interp *interp, Tcl_LoadHandle handlePtr)
 }
 
diff --git a/generic/tclInt.decls b/generic/tclInt.decls
index d54d87c..b7b23d5 100644
--- a/generic/tclInt.decls
+++ b/generic/tclInt.decls
@@ -13,13 +13,14 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #
-# RCS: @(#) $Id: tclInt.decls,v 1.147 2010/07/02 22:31:50 dgp Exp $
+# RCS: @(#) $Id: tclInt.decls,v 1.148 2010/09/15 07:33:55 nijtmans Exp $
 
 library tcl
 
 # Define the unsupported generic interfaces.
 
 interface tclInt
+scspec EXTERN
 
 # Declare each of the functions in the unsupported internal Tcl
 # interface.  These interfaces are allowed to changed between versions.
@@ -27,623 +28,623 @@ interface tclInt
 # be changed between versions to avoid gratuitous incompatibilities.
 
 # Replaced by Tcl_FSAccess in 8.4:
-#declare 0 generic {
+#declare 0 {
 #    int TclAccess(const char *path, int mode)
 #}
-#declare 1 generic {
+#declare 1 {
 #    int TclAccessDeleteProc(TclAccessProc_ *proc)
 #}
-#declare 2 generic {
+#declare 2 {
 #    int TclAccessInsertProc(TclAccessProc_ *proc)
 #}
-declare 3 generic {
+declare 3 {
     void TclAllocateFreeObjects(void)
 }
 # Replaced by TclpChdir in 8.1:
-#  declare 4 generic {
+#  declare 4 {
 #      int TclChdir(Tcl_Interp *interp, char *dirName)
 #  }
-declare 5 generic {
+declare 5 {
     int TclCleanupChildren(Tcl_Interp *interp, int numPids, Tcl_Pid *pidPtr,
 	    Tcl_Channel errorChan)
 }
-declare 6 generic {
+declare 6 {
     void TclCleanupCommand(Command *cmdPtr)
 }
-declare 7 generic {
+declare 7 {
     int TclCopyAndCollapse(int count, const char *src, char *dst)
 }
-declare 8 generic {
+declare 8 {
     int TclCopyChannelOld(Tcl_Interp *interp, Tcl_Channel inChan,
 	    Tcl_Channel outChan, int toRead, Tcl_Obj *cmdPtr)
 }
 
 # TclCreatePipeline unofficially exported for use by BLT.
 
-declare 9 generic {
+declare 9 {
     int TclCreatePipeline(Tcl_Interp *interp, int argc, const char **argv,
 	    Tcl_Pid **pidArrayPtr, TclFile *inPipePtr, TclFile *outPipePtr,
 	    TclFile *errFilePtr)
 }
-declare 10 generic {
+declare 10 {
     int TclCreateProc(Tcl_Interp *interp, Namespace *nsPtr,
 	    const char *procName,
 	    Tcl_Obj *argsPtr, Tcl_Obj *bodyPtr, Proc **procPtrPtr)
 }
-declare 11 generic {
+declare 11 {
     void TclDeleteCompiledLocalVars(Interp *iPtr, CallFrame *framePtr)
 }
-declare 12 generic {
+declare 12 {
     void TclDeleteVars(Interp *iPtr, TclVarHashTable *tablePtr)
 }
 # Removed in 8.5
-#declare 13 generic {
+#declare 13 {
 #    int TclDoGlob(Tcl_Interp *interp, char *separators,
 #	    Tcl_DString *headPtr, char *tail, Tcl_GlobTypeData *types)
 #}
-declare 14 generic {
+declare 14 {
     void TclDumpMemoryInfo(FILE *outFile)
 }
 # Removed in 8.1:
-#  declare 15 generic {
+#  declare 15 {
 #      void TclExpandParseValue(ParseValue *pvPtr, int needed)
 #  }
-declare 16 generic {
+declare 16 {
     void TclExprFloatError(Tcl_Interp *interp, double value)
 }
 # Removed in 8.4
-#declare 17 generic {
+#declare 17 {
 #    int TclFileAttrsCmd(Tcl_Interp *interp, int objc, Tcl_Obj *const objv[])
 #}
-#declare 18 generic {
+#declare 18 {
 #    int TclFileCopyCmd(Tcl_Interp *interp, int argc, char **argv)
 #}
-#declare 19 generic {
+#declare 19 {
 #    int TclFileDeleteCmd(Tcl_Interp *interp, int argc, char **argv)
 #}
-#declare 20 generic {
+#declare 20 {
 #    int TclFileMakeDirsCmd(Tcl_Interp *interp, int argc, char **argv)
 #}
-#declare 21 generic {
+#declare 21 {
 #    int TclFileRenameCmd(Tcl_Interp *interp, int argc, char **argv)
 #}
-declare 22 generic {
+declare 22 {
     int TclFindElement(Tcl_Interp *interp, const char *listStr,
 	    int listLength, const char **elementPtr, const char **nextPtr,
 	    int *sizePtr, int *bracePtr)
 }
-declare 23 generic {
+declare 23 {
     Proc *TclFindProc(Interp *iPtr, const char *procName)
 }
 # Replaced with macro (see tclInt.h) in Tcl 8.5
-#declare 24 generic {
+#declare 24 {
 #    int TclFormatInt(char *buffer, long n)
 #}
-declare 25 generic {
+declare 25 {
     void TclFreePackageInfo(Interp *iPtr)
 }
 # Removed in 8.1:
-#  declare 26 generic {
+#  declare 26 {
 #      char *TclGetCwd(Tcl_Interp *interp)
 #  }
 # Removed in 8.5
-#declare 27 generic {
+#declare 27 {
 #    int TclGetDate(char *p, unsigned long now, long zone,
 #	    unsigned long *timePtr)
 #}
-declare 28 generic {
+declare 28 {
     Tcl_Channel TclpGetDefaultStdChannel(int type)
 }
 # Removed in 8.4b2:
-#declare 29 generic {
+#declare 29 {
 #    Tcl_Obj *TclGetElementOfIndexedArray(Tcl_Interp *interp,
 #	    int localIndex, Tcl_Obj *elemPtr, int flags)
 #}
 # Replaced by char *TclGetEnv(const char *name, Tcl_DString *valuePtr) in 8.1:
-#  declare 30 generic {
+#  declare 30 {
 #      char *TclGetEnv(const char *name)
 #  }
-declare 31 generic {
+declare 31 {
     const char *TclGetExtension(const char *name)
 }
-declare 32 generic {
+declare 32 {
     int TclGetFrame(Tcl_Interp *interp, const char *str,
 	    CallFrame **framePtrPtr)
 }
 # Removed in Tcl 8.5
-#declare 33 generic {
+#declare 33 {
 #    TclCmdProcType TclGetInterpProc(void)
 #}
-declare 34 generic {
+declare 34 {
     int TclGetIntForIndex(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    int endValue, int *indexPtr)
 }
 # Removed in 8.4b2:
-#declare 35 generic {
+#declare 35 {
 #    Tcl_Obj *TclGetIndexedScalar(Tcl_Interp *interp, int localIndex,
 #	    int flags)
 #}
 # Removed in 8.6a2
-#declare 36 generic {
+#declare 36 {
 #    int TclGetLong(Tcl_Interp *interp, const char *str, long *longPtr)
 #}
-declare 37 generic {
+declare 37 {
     int TclGetLoadedPackages(Tcl_Interp *interp, const char *targetName)
 }
-declare 38 generic {
+declare 38 {
     int TclGetNamespaceForQualName(Tcl_Interp *interp, const char *qualName,
 	    Namespace *cxtNsPtr, int flags, Namespace **nsPtrPtr,
 	    Namespace **altNsPtrPtr, Namespace **actualCxtPtrPtr,
 	    const char **simpleNamePtr)
 }
-declare 39 generic {
+declare 39 {
     TclObjCmdProcType TclGetObjInterpProc(void)
 }
-declare 40 generic {
+declare 40 {
     int TclGetOpenMode(Tcl_Interp *interp, const char *str, int *seekFlagPtr)
 }
-declare 41 generic {
+declare 41 {
     Tcl_Command TclGetOriginalCommand(Tcl_Command command)
 }
-declare 42 generic {
+declare 42 {
     CONST86 char *TclpGetUserHome(const char *name, Tcl_DString *bufferPtr)
 }
 # Removed in Tcl 8.5a2
-#declare 43 generic {
+#declare 43 {
 #    int TclGlobalInvoke(Tcl_Interp *interp, int argc, const char **argv,
 #	    int flags)
 #}
-declare 44 generic {
+declare 44 {
     int TclGuessPackageName(const char *fileName, Tcl_DString *bufPtr)
 }
-declare 45 generic {
+declare 45 {
     int TclHideUnsafeCommands(Tcl_Interp *interp)
 }
-declare 46 generic {
+declare 46 {
     int TclInExit(void)
 }
 # Removed in 8.4b2:
-#declare 47 generic {
+#declare 47 {
 #    Tcl_Obj *TclIncrElementOfIndexedArray(Tcl_Interp *interp,
 #	    int localIndex, Tcl_Obj *elemPtr, long incrAmount)
 #}
 # Removed in 8.4b2:
-#declare 48 generic {
+#declare 48 {
 #    Tcl_Obj *TclIncrIndexedScalar(Tcl_Interp *interp, int localIndex,
 #	    long incrAmount)
 #}
-#declare 49 generic {
+#declare 49 {
 #    Tcl_Obj *TclIncrVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr,
 #	    Tcl_Obj *part2Ptr, long incrAmount, int part1NotParsed)
 #}
-declare 50 generic {
+declare 50 {
     void TclInitCompiledLocals(Tcl_Interp *interp, CallFrame *framePtr,
 	    Namespace *nsPtr)
 }
-declare 51 generic {
+declare 51 {
     int TclInterpInit(Tcl_Interp *interp)
 }
 # Removed in Tcl 8.5a2
-#declare 52 generic {
+#declare 52 {
 #    int TclInvoke(Tcl_Interp *interp, int argc, const char **argv,
 #	    int flags)
 #}
-declare 53 generic {
+declare 53 {
     int TclInvokeObjectCommand(ClientData clientData, Tcl_Interp *interp,
 	    int argc, CONST84 char **argv)
 }
-declare 54 generic {
+declare 54 {
     int TclInvokeStringCommand(ClientData clientData, Tcl_Interp *interp,
 	    int objc, Tcl_Obj *const objv[])
 }
-declare 55 generic {
+declare 55 {
     Proc *TclIsProc(Command *cmdPtr)
 }
 # Replaced with TclpLoadFile in 8.1:
-#  declare 56 generic {
+#  declare 56 {
 #      int TclLoadFile(Tcl_Interp *interp, char *fileName, char *sym1,
 #  	    char *sym2, Tcl_PackageInitProc **proc1Ptr,
 #  	    Tcl_PackageInitProc **proc2Ptr)
 #  }
 # Signature changed to take a length in 8.1:
-#  declare 57 generic {
+#  declare 57 {
 #      int TclLooksLikeInt(char *p)
 #  }
-declare 58 generic {
+declare 58 {
     Var *TclLookupVar(Tcl_Interp *interp, const char *part1, const char *part2,
 	    int flags, const char *msg, int createPart1, int createPart2,
 	    Var **arrayPtrPtr)
 }
 # Replaced by Tcl_FSMatchInDirectory in 8.4
-#declare 59 generic {
+#declare 59 {
 #    int TclpMatchFiles(Tcl_Interp *interp, char *separators,
 #	    Tcl_DString *dirPtr, char *pattern, char *tail)
 #}
-declare 60 generic {
+declare 60 {
     int TclNeedSpace(const char *start, const char *end)
 }
-declare 61 generic {
+declare 61 {
     Tcl_Obj *TclNewProcBodyObj(Proc *procPtr)
 }
-declare 62 generic {
+declare 62 {
     int TclObjCommandComplete(Tcl_Obj *cmdPtr)
 }
-declare 63 generic {
+declare 63 {
     int TclObjInterpProc(ClientData clientData, Tcl_Interp *interp,
 	    int objc, Tcl_Obj *const objv[])
 }
-declare 64 generic {
+declare 64 {
     int TclObjInvoke(Tcl_Interp *interp, int objc, Tcl_Obj *const objv[],
 	    int flags)
 }
 # Removed in Tcl 8.5a2
-#declare 65 generic {
+#declare 65 {
 #    int TclObjInvokeGlobal(Tcl_Interp *interp, int objc,
 #	    Tcl_Obj *const objv[], int flags)
 #}
-#declare 66 generic {
+#declare 66 {
 #    int TclOpenFileChannelDeleteProc(TclOpenFileChannelProc_ *proc)
 #}
-#declare 67 generic {
+#declare 67 {
 #    int TclOpenFileChannelInsertProc(TclOpenFileChannelProc_ *proc)
 #}
 # Replaced by Tcl_FSAccess in 8.4:
-#declare 68 generic {
+#declare 68 {
 #    int TclpAccess(const char *path, int mode)
 #}
-declare 69 generic {
+declare 69 {
     char *TclpAlloc(unsigned int size)
 }
-#declare 70 generic {
+#declare 70 {
 #    int TclpCopyFile(const char *source, const char *dest)
 #}
-#declare 71 generic {
+#declare 71 {
 #    int TclpCopyDirectory(const char *source, const char *dest,
 #	    Tcl_DString *errorPtr)
 #}
-#declare 72 generic {
+#declare 72 {
 #    int TclpCreateDirectory(const char *path)
 #}
-#declare 73 generic {
+#declare 73 {
 #    int TclpDeleteFile(const char *path)
 #}
-declare 74 generic {
+declare 74 {
     void TclpFree(char *ptr)
 }
-declare 75 generic {
+declare 75 {
     unsigned long TclpGetClicks(void)
 }
-declare 76 generic {
+declare 76 {
     unsigned long TclpGetSeconds(void)
 }
 
 # deprecated
-declare 77 generic {
+declare 77 {
     void TclpGetTime(Tcl_Time *time)
 }
-declare 78 generic {
+declare 78 {
     int TclpGetTimeZone(unsigned long time)
 }
 # Replaced by Tcl_FSListVolumes in 8.4:
-#declare 79 generic {
+#declare 79 {
 #    int TclpListVolumes(Tcl_Interp *interp)
 #}
 # Replaced by Tcl_FSOpenFileChannel in 8.4:
-#declare 80 generic {
+#declare 80 {
 #    Tcl_Channel TclpOpenFileChannel(Tcl_Interp *interp, char *fileName,
 #	    char *modeString, int permissions)
 #}
-declare 81 generic {
+declare 81 {
     char *TclpRealloc(char *ptr, unsigned int size)
 }
-#declare 82 generic {
+#declare 82 {
 #    int TclpRemoveDirectory(const char *path, int recursive,
 #	    Tcl_DString *errorPtr)
 #}
-#declare 83 generic {
+#declare 83 {
 #    int TclpRenameFile(const char *source, const char *dest)
 #}
 # Removed in 8.1:
-#  declare 84 generic {
+#  declare 84 {
 #      int TclParseBraces(Tcl_Interp *interp, char *str, char **termPtr,
 #  	    ParseValue *pvPtr)
 #  }
-#  declare 85 generic {
+#  declare 85 {
 #      int TclParseNestedCmd(Tcl_Interp *interp, char *str, int flags,
 #  	    char **termPtr, ParseValue *pvPtr)
 #  }
-#  declare 86 generic {
+#  declare 86 {
 #      int TclParseQuotes(Tcl_Interp *interp, char *str, int termChar,
 #  	    int flags, char **termPtr, ParseValue *pvPtr)
 #  }
-#  declare 87 generic {
+#  declare 87 {
 #      void TclPlatformInit(Tcl_Interp *interp)
 #  }
-declare 88 generic {
+declare 88 {
     char *TclPrecTraceProc(ClientData clientData, Tcl_Interp *interp,
 	    const char *name1, const char *name2, int flags)
 }
-declare 89 generic {
+declare 89 {
     int TclPreventAliasLoop(Tcl_Interp *interp, Tcl_Interp *cmdInterp,
 	    Tcl_Command cmd)
 }
 # Removed in 8.1 (only available if compiled with TCL_COMPILE_DEBUG):
-#  declare 90 generic {
+#  declare 90 {
 #      void TclPrintByteCodeObj(Tcl_Interp *interp, Tcl_Obj *objPtr)
 #  }
-declare 91 generic {
+declare 91 {
     void TclProcCleanupProc(Proc *procPtr)
 }
-declare 92 generic {
+declare 92 {
     int TclProcCompileProc(Tcl_Interp *interp, Proc *procPtr,
 	    Tcl_Obj *bodyPtr, Namespace *nsPtr, const char *description,
 	    const char *procName)
 }
-declare 93 generic {
+declare 93 {
     void TclProcDeleteProc(ClientData clientData)
 }
 # Removed in Tcl 8.5:
-#declare 94 generic {
+#declare 94 {
 #    int TclProcInterpProc(ClientData clientData, Tcl_Interp *interp,
 #	    int argc, const char **argv)
 #}
 # Replaced by Tcl_FSStat in 8.4:
-#declare 95 generic {
+#declare 95 {
 #    int TclpStat(const char *path, Tcl_StatBuf *buf)
 #}
-declare 96 generic {
+declare 96 {
     int TclRenameCommand(Tcl_Interp *interp, const char *oldName,
             const char *newName)
 }
-declare 97 generic {
+declare 97 {
     void TclResetShadowedCmdRefs(Tcl_Interp *interp, Command *newCmdPtr)
 }
-declare 98 generic {
+declare 98 {
     int TclServiceIdle(void)
 }
 # Removed in 8.4b2:
-#declare 99 generic {
+#declare 99 {
 #    Tcl_Obj *TclSetElementOfIndexedArray(Tcl_Interp *interp, int localIndex,
 #	    Tcl_Obj *elemPtr, Tcl_Obj *objPtr, int flags)
 #}
 # Removed in 8.4b2:
-#declare 100 generic {
+#declare 100 {
 #    Tcl_Obj *TclSetIndexedScalar(Tcl_Interp *interp, int localIndex,
 #	    Tcl_Obj *objPtr, int flags)
 #}
-declare 101 generic {
+declare 101 {
     CONST86 char *TclSetPreInitScript(const char *string)
 }
-declare 102 generic {
+declare 102 {
     void TclSetupEnv(Tcl_Interp *interp)
 }
-declare 103 generic {
+declare 103 {
     int TclSockGetPort(Tcl_Interp *interp, const char *str, const char *proto,
 	    int *portPtr)
 }
-declare 104 generic {
+declare 104 {
     int TclSockMinimumBuffers(int sock, int size)
 }
 # Replaced by Tcl_FSStat in 8.4:
-#declare 105 generic {
+#declare 105 {
 #    int TclStat(const char *path, Tcl_StatBuf *buf)
 #}
-#declare 106 generic {
+#declare 106 {
 #    int TclStatDeleteProc(TclStatProc_ *proc)
 #}
-#declare 107 generic {
+#declare 107 {
 #    int TclStatInsertProc(TclStatProc_ *proc)
 #}
-declare 108 generic {
+declare 108 {
     void TclTeardownNamespace(Namespace *nsPtr)
 }
-declare 109 generic {
+declare 109 {
     int TclUpdateReturnInfo(Interp *iPtr)
 }
 # Removed in 8.1:
-#  declare 110 generic {
+#  declare 110 {
 #      char *TclWordEnd(char *start, char *lastChar, int nested, int *semiPtr)
 #  }
 
 # Procedures used in conjunction with Tcl namespaces. They are
 # defined here instead of in tcl.decls since they are not stable yet.
 
-declare 111 generic {
+declare 111 {
     void Tcl_AddInterpResolvers(Tcl_Interp *interp, const char *name,
 	    Tcl_ResolveCmdProc *cmdProc, Tcl_ResolveVarProc *varProc,
 	    Tcl_ResolveCompiledVarProc *compiledVarProc)
 }
-declare 112 generic {
+declare 112 {
     int Tcl_AppendExportList(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
 	    Tcl_Obj *objPtr)
 }
-declare 113 generic {
+declare 113 {
     Tcl_Namespace *Tcl_CreateNamespace(Tcl_Interp *interp, const char *name,
 	    ClientData clientData, Tcl_NamespaceDeleteProc *deleteProc)
 }
-declare 114 generic {
+declare 114 {
     void Tcl_DeleteNamespace(Tcl_Namespace *nsPtr)
 }
-declare 115 generic {
+declare 115 {
     int Tcl_Export(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
 	    const char *pattern, int resetListFirst)
 }
-declare 116 generic {
+declare 116 {
     Tcl_Command Tcl_FindCommand(Tcl_Interp *interp, const char *name,
 	    Tcl_Namespace *contextNsPtr, int flags)
 }
-declare 117 generic {
+declare 117 {
     Tcl_Namespace *Tcl_FindNamespace(Tcl_Interp *interp, const char *name,
 	    Tcl_Namespace *contextNsPtr, int flags)
 }
-declare 118 generic {
+declare 118 {
     int Tcl_GetInterpResolvers(Tcl_Interp *interp, const char *name,
 	    Tcl_ResolverInfo *resInfo)
 }
-declare 119 generic {
+declare 119 {
     int Tcl_GetNamespaceResolvers(Tcl_Namespace *namespacePtr,
 	    Tcl_ResolverInfo *resInfo)
 }
-declare 120 generic {
+declare 120 {
     Tcl_Var Tcl_FindNamespaceVar(Tcl_Interp *interp, const char *name,
 	    Tcl_Namespace *contextNsPtr, int flags)
 }
-declare 121 generic {
+declare 121 {
     int Tcl_ForgetImport(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
 	    const char *pattern)
 }
-declare 122 generic {
+declare 122 {
     Tcl_Command Tcl_GetCommandFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr)
 }
-declare 123 generic {
+declare 123 {
     void Tcl_GetCommandFullName(Tcl_Interp *interp, Tcl_Command command,
 	    Tcl_Obj *objPtr)
 }
-declare 124 generic {
+declare 124 {
     Tcl_Namespace *Tcl_GetCurrentNamespace(Tcl_Interp *interp)
 }
-declare 125 generic {
+declare 125 {
     Tcl_Namespace *Tcl_GetGlobalNamespace(Tcl_Interp *interp)
 }
-declare 126 generic {
+declare 126 {
     void Tcl_GetVariableFullName(Tcl_Interp *interp, Tcl_Var variable,
 	    Tcl_Obj *objPtr)
 }
-declare 127 generic {
+declare 127 {
     int Tcl_Import(Tcl_Interp *interp, Tcl_Namespace *nsPtr,
 	    const char *pattern, int allowOverwrite)
 }
-declare 128 generic {
+declare 128 {
     void Tcl_PopCallFrame(Tcl_Interp *interp)
 }
-declare 129 generic {
+declare 129 {
     int Tcl_PushCallFrame(Tcl_Interp *interp, Tcl_CallFrame *framePtr,
 	    Tcl_Namespace *nsPtr, int isProcCallFrame)
 }
-declare 130 generic {
+declare 130 {
     int Tcl_RemoveInterpResolvers(Tcl_Interp *interp, const char *name)
 }
-declare 131 generic {
+declare 131 {
     void Tcl_SetNamespaceResolvers(Tcl_Namespace *namespacePtr,
 	    Tcl_ResolveCmdProc *cmdProc, Tcl_ResolveVarProc *varProc,
 	    Tcl_ResolveCompiledVarProc *compiledVarProc)
 }
-declare 132 generic {
+declare 132 {
     int TclpHasSockets(Tcl_Interp *interp)
 }
-declare 133 generic {
+declare 133 {
     struct tm *TclpGetDate(const time_t *time, int useGMT)
 }
 # Removed in 8.5
-#declare 134 generic {
+#declare 134 {
 #    size_t TclpStrftime(char *s, size_t maxsize, const char *format,
 #	    const struct tm *t, int useGMT)
 #}
-#declare 135 generic {
+#declare 135 {
 #    int TclpCheckStackSpace(void)
 #}
 
 # Added in 8.1:
 
-#declare 137 generic {
+#declare 137 {
 #   int TclpChdir(const char *dirName)
 #}
-declare 138 generic {
+declare 138 {
     CONST84_RETURN char *TclGetEnv(const char *name, Tcl_DString *valuePtr)
 }
-#declare 139 generic {
+#declare 139 {
 #    int TclpLoadFile(Tcl_Interp *interp, char *fileName, char *sym1,
 #	    char *sym2, Tcl_PackageInitProc **proc1Ptr,
 #	    Tcl_PackageInitProc **proc2Ptr, ClientData *clientDataPtr)
 #}
-#declare 140 generic {
+#declare 140 {
 #    int TclLooksLikeInt(const char *bytes, int length)
 #}
 # This is used by TclX, but should otherwise be considered private
-declare 141 generic {
+declare 141 {
     CONST84_RETURN char *TclpGetCwd(Tcl_Interp *interp, Tcl_DString *cwdPtr)
 }
-declare 142 generic {
+declare 142 {
     int TclSetByteCodeFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    CompileHookProc *hookProc, ClientData clientData)
 }
-declare 143 generic {
+declare 143 {
     int TclAddLiteralObj(struct CompileEnv *envPtr, Tcl_Obj *objPtr,
 	    LiteralEntry **litPtrPtr)
 }
-declare 144 generic {
+declare 144 {
     void TclHideLiteral(Tcl_Interp *interp, struct CompileEnv *envPtr,
 	    int index)
 }
-declare 145 generic {
+declare 145 {
     const struct AuxDataType *TclGetAuxDataType(const char *typeName)
 }
-declare 146 generic {
+declare 146 {
     TclHandle TclHandleCreate(void *ptr)
 }
-declare 147 generic {
+declare 147 {
     void TclHandleFree(TclHandle handle)
 }
-declare 148 generic {
+declare 148 {
     TclHandle TclHandlePreserve(TclHandle handle)
 }
-declare 149 generic {
+declare 149 {
     void TclHandleRelease(TclHandle handle)
 }
 
 # Added for Tcl 8.2
 
-declare 150 generic {
+declare 150 {
     int TclRegAbout(Tcl_Interp *interp, Tcl_RegExp re)
 }
-declare 151 generic {
+declare 151 {
     void TclRegExpRangeUniChar(Tcl_RegExp re, int index, int *startPtr,
 	    int *endPtr)
 }
-declare 152 generic {
+declare 152 {
     void TclSetLibraryPath(Tcl_Obj *pathPtr)
 }
-declare 153 generic {
+declare 153 {
     Tcl_Obj *TclGetLibraryPath(void)
 }
 
 # moved to tclTest.c (static) in 8.3.2/8.4a2
-#declare 154 generic {
+#declare 154 {
 #    int TclTestChannelCmd(ClientData clientData,
 #    Tcl_Interp *interp, int argc, char **argv)
 #}
-#declare 155 generic {
+#declare 155 {
 #    int TclTestChannelEventCmd(ClientData clientData,
 #	     Tcl_Interp *interp, int argc, char **argv)
 #}
 
-declare 156 generic {
+declare 156 {
     void TclRegError(Tcl_Interp *interp, const char *msg,
 	    int status)
 }
-declare 157 generic {
+declare 157 {
     Var *TclVarTraceExists(Tcl_Interp *interp, const char *varName)
 }
 # REMOVED - use public Tcl_SetStartupScript()
-#declare 158 generic {
+#declare 158 {
 #    void TclSetStartupScriptFileName(const char *filename)
 #}
 # REMOVED - use public Tcl_GetStartupScript()
-#declare 159 generic {
+#declare 159 {
 #    const char *TclGetStartupScriptFileName(void)
 #}
-#declare 160 generic {
+#declare 160 {
 #    int TclpMatchFilesTypes(Tcl_Interp *interp, char *separators,
 #	    Tcl_DString *dirPtr, char *pattern, char *tail,
 #	    GlobTypeData *types)
 #}
 
 # new in 8.3.2/8.4a2
-declare 161 generic {
+declare 161 {
     int TclChannelTransform(Tcl_Interp *interp, Tcl_Channel chan,
 	    Tcl_Obj *cmdObjPtr)
 }
-declare 162 generic {
+declare 162 {
     void TclChannelEventScriptInvoker(ClientData clientData, int flags)
 }
 
@@ -652,7 +653,7 @@ declare 162 generic {
 # "tclInt.h". It is described in "tclCompile.h". Use a cast to the
 # correct type when calling this procedure.
 
-declare 163 generic {
+declare 163 {
     const void *TclGetInstructionTable(void)
 }
 
@@ -660,99 +661,99 @@ declare 163 generic {
 # "CompileEnv*" but we do not want to describe this structure in
 # "tclInt.h". It is described in "tclCompile.h".
 
-declare 164 generic {
+declare 164 {
     void TclExpandCodeArray(void *envPtr)
 }
 
 # These functions are vfs aware, but are generally only useful internally.
-declare 165 generic {
+declare 165 {
     void TclpSetInitialEncodings(void)
 }
 
 # New function due to TIP #33
-declare 166 generic {
+declare 166 {
     int TclListObjSetElement(Tcl_Interp *interp, Tcl_Obj *listPtr,
 	    int index, Tcl_Obj *valuePtr)
 }
 
 # VFS-aware versions of Tcl*StartupScriptFileName (158 and 159 above)
 # REMOVED - use public Tcl_SetStartupScript()
-#declare 167 generic {
+#declare 167 {
 #    void TclSetStartupScriptPath(Tcl_Obj *pathPtr)
 #}
 # REMOVED - use public Tcl_GetStartupScript()
-#declare 168 generic {
+#declare 168 {
 #    Tcl_Obj *TclGetStartupScriptPath(void)
 #}
 # variant of Tcl_UtfNCmp that takes n as bytes, not chars
-declare 169 generic {
+declare 169 {
     int TclpUtfNcmp2(const char *s1, const char *s2, unsigned long n)
 }
-declare 170 generic {
+declare 170 {
     int TclCheckInterpTraces(Tcl_Interp *interp, const char *command,
             int numChars, Command *cmdPtr, int result, int traceFlags,
 	    int objc, Tcl_Obj *const objv[])
 }
-declare 171 generic {
+declare 171 {
     int TclCheckExecutionTraces(Tcl_Interp *interp, const char *command,
             int numChars, Command *cmdPtr, int result, int traceFlags,
 	    int objc, Tcl_Obj *const objv[])
 }
-declare 172 generic {
+declare 172 {
     int TclInThreadExit(void)
 }
 
 # added for 8.4.2
 
-declare 173 generic {
+declare 173 {
     int TclUniCharMatch(const Tcl_UniChar *string, int strLen,
 	    const Tcl_UniChar *pattern, int ptnLen, int flags)
 }
 
 # added for 8.4.3
 
-#declare 174 generic {
+#declare 174 {
 #    Tcl_Obj *TclIncrWideVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr,
 #	    Tcl_Obj *part2Ptr, Tcl_WideInt wideIncrAmount, int part1NotParsed)
 #}
 
 # Factoring out of trace code
 
-declare 175 generic {
+declare 175 {
     int TclCallVarTraces(Interp *iPtr, Var *arrayPtr, Var *varPtr,
 	    const char *part1, const char *part2, int flags, int leaveErrMsg)
 }
-declare 176 generic {
+declare 176 {
     void TclCleanupVar(Var *varPtr, Var *arrayPtr)
 }
-declare 177 generic {
+declare 177 {
     void TclVarErrMsg(Tcl_Interp *interp, const char *part1, const char *part2,
 	    const char *operation, const char *reason)
 }
 # TIP 338 made these public - now declared in tcl.h
-#declare 178 generic {
+#declare 178 {
 #    void Tcl_SetStartupScript(Tcl_Obj *pathPtr, const char *encodingName)
 #}
-#declare 179 generic {
+#declare 179 {
 #    Tcl_Obj *Tcl_GetStartupScript(const char **encodingNamePtr)
 #}
 
 # REMOVED
 # Allocate lists without copying arrays
-# declare 180 generic {
+# declare 180 {
 #    Tcl_Obj *TclNewListObjDirect(int objc, Tcl_Obj **objv)
 # }
-#declare 181 generic {
+#declare 181 {
 #    Tcl_Obj *TclDbNewListObjDirect(int objc, Tcl_Obj **objv,
 #	    const char *file, int line)
 #}
 
-# TclpGmtime and TclpLocaltime promoted to the generic interface from unix
+# TclpGmtime and TclpLocaltime promoted to the interface from unix
 
-declare 182 generic {
+declare 182 {
      struct tm *TclpLocaltime(const time_t *clock)
 }
-declare 183 generic {
+declare 183 {
      struct tm *TclpGmtime(const time_t *clock)
 }
 
@@ -761,43 +762,43 @@ declare 183 generic {
 ### REMOVED on grounds it should never have been exposed. All these
 ### functions are now either static in tclThreadStorage.c or
 ### MODULE_SCOPE.
-# declare 184 generic {
+# declare 184 {
 #      void TclThreadStorageLockInit(void)
 # }
-# declare 185 generic {
+# declare 185 {
 #      void TclThreadStorageLock(void)
 # }
-# declare 186 generic {
+# declare 186 {
 #      void TclThreadStorageUnlock(void)
 # }
-# declare 187 generic {
+# declare 187 {
 #      void TclThreadStoragePrint(FILE *outFile, int flags)
 # }
-# declare 188 generic {
+# declare 188 {
 #      Tcl_HashTable *TclThreadStorageGetHashTable(Tcl_ThreadId id)
 # }
-# declare 189 generic {
+# declare 189 {
 #      Tcl_HashTable *TclThreadStorageInit(Tcl_ThreadId id, void *reserved)
 # }
-# declare 190 generic {
+# declare 190 {
 #      void TclThreadStorageDataKeyInit(Tcl_ThreadDataKey *keyPtr)
 # }
-# declare 191 generic {
+# declare 191 {
 #      void *TclThreadStorageDataKeyGet(Tcl_ThreadDataKey *keyPtr)
 # }
-# declare 192 generic {
+# declare 192 {
 #      void TclThreadStorageDataKeySet(Tcl_ThreadDataKey *keyPtr, void *data)
 # }
-# declare 193 generic {
+# declare 193 {
 #      void TclFinalizeThreadStorageThread(Tcl_ThreadId id)
 # }
-# declare 194 generic {
+# declare 194 {
 #      void TclFinalizeThreadStorage(void)
 # }
-# declare 195 generic {
+# declare 195 {
 #      void TclFinalizeThreadStorageData(Tcl_ThreadDataKey *keyPtr)
 # }
-# declare 196 generic {
+# declare 196 {
 #      void TclFinalizeThreadStorageDataKey(Tcl_ThreadDataKey *keyPtr)
 # }
 
@@ -805,193 +806,193 @@ declare 183 generic {
 # Added in tcl8.5a5 for compiler/executor experimentation.
 # Disabled in Tcl 8.5.1; experiments terminated. :/
 #
-#declare 197 generic {
+#declare 197 {
 #    int TclCompEvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 #		        const CmdFrame *invoker, int word)
 #}
-declare 198 generic {
+declare 198 {
     int TclObjGetFrame(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    CallFrame **framePtrPtr)
 }
 
-#declare 199 generic {
+#declare 199 {
 #    int TclMatchIsTrivial(const char *pattern)
 #}
 
 # 200-208 exported for use by the test suite [Bug 1054748]
-declare 200 generic {
+declare 200 {
     int TclpObjRemoveDirectory(Tcl_Obj *pathPtr, int recursive,
 	Tcl_Obj **errorPtr)
 }
-declare 201 generic {
+declare 201 {
     int TclpObjCopyDirectory(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr,
 	Tcl_Obj **errorPtr)
 }
-declare 202 generic {
+declare 202 {
     int TclpObjCreateDirectory(Tcl_Obj *pathPtr)
 }
-declare 203 generic {
+declare 203 {
     int TclpObjDeleteFile(Tcl_Obj *pathPtr)
 }
-declare 204 generic {
+declare 204 {
     int TclpObjCopyFile(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr)
 }
-declare 205 generic {
+declare 205 {
     int TclpObjRenameFile(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr)
 }
-declare 206 generic {
+declare 206 {
     int TclpObjStat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf)
 }
-declare 207 generic {
+declare 207 {
     int TclpObjAccess(Tcl_Obj *pathPtr, int mode)
 }
-declare 208 generic {
+declare 208 {
     Tcl_Channel TclpOpenFileChannel(Tcl_Interp *interp,
 	    Tcl_Obj *pathPtr, int mode, int permissions)
 }
 # Made public by TIP 258
-#declare 209 generic {
+#declare 209 {
 #    Tcl_Obj *TclGetEncodingSearchPath(void)
 #}
-#declare 210 generic {
+#declare 210 {
 #    int TclSetEncodingSearchPath(Tcl_Obj *searchPath)
 #}
-#declare 211 generic {
+#declare 211 {
 #    const char *TclpGetEncodingNameFromEnvironment(Tcl_DString *bufPtr)
 #}
-declare 212 generic {
+declare 212 {
     void TclpFindExecutable(const char *argv0)
 }
-declare 213 generic {
+declare 213 {
     Tcl_Obj *TclGetObjNameOfExecutable(void)
 }
-declare 214 generic {
+declare 214 {
     void TclSetObjNameOfExecutable(Tcl_Obj *name, Tcl_Encoding encoding)
 }
-declare 215 generic {
+declare 215 {
     void *TclStackAlloc(Tcl_Interp *interp, int numBytes)
 }
-declare 216 generic {
+declare 216 {
     void TclStackFree(Tcl_Interp *interp, void *freePtr)
 }
-declare 217 generic {
+declare 217 {
     int TclPushStackFrame(Tcl_Interp *interp, Tcl_CallFrame **framePtrPtr,
             Tcl_Namespace *namespacePtr, int isProcCallFrame)
 }
-declare 218 generic {
+declare 218 {
     void TclPopStackFrame(Tcl_Interp *interp)
 }
 
 # for use in tclTest.c
-declare 224 generic {
+declare 224 {
     TclPlatformType *TclGetPlatform(void)
 }
 
 #
-declare 225 generic {
+declare 225 {
     Tcl_Obj *TclTraceDictPath(Tcl_Interp *interp, Tcl_Obj *rootPtr,
 	    int keyc, Tcl_Obj *const keyv[], int flags)
 }
-declare 226 generic {
+declare 226 {
     int TclObjBeingDeleted(Tcl_Obj *objPtr)
 }
-declare 227 generic {
+declare 227 {
     void TclSetNsPath(Namespace *nsPtr, int pathLength,
             Tcl_Namespace *pathAry[])
 }
 #  Used to be needed for TclOO-extension; unneeded now that TclOO is in the
 #  core and NRE-enabled
-#  declare 228 generic {
+#  declare 228 {
 #      int TclObjInterpProcCore(register Tcl_Interp *interp, Tcl_Obj *procNameObj,
 #             int skip, ProcErrorProc *errorProc)
 #  }
-declare 229 generic {
+declare 229 {
     int	TclPtrMakeUpvar(Tcl_Interp *interp, Var *otherP1Ptr,
 	    const char *myName, int myFlags, int index)
 }
-declare 230 generic {
+declare 230 {
     Var *TclObjLookupVar(Tcl_Interp *interp, Tcl_Obj *part1Ptr,
 	    const char *part2, int flags, const char *msg,
 	    const int createPart1, const int createPart2, Var **arrayPtrPtr)
 }
-declare 231 generic {
+declare 231 {
     int	TclGetNamespaceFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,
 	    Tcl_Namespace **nsPtrPtr)
 }
 
 # Bits and pieces of TIP#280's guts
-declare 232 generic {
+declare 232 {
     int TclEvalObjEx(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags,
 	    const CmdFrame *invoker, int word)
 }
-declare 233 generic {
+declare 233 {
     void TclGetSrcInfoForPc(CmdFrame *contextPtr)
 }
 
 # Exports for VarReform compat: Itcl, XOTcl like to peek into our varTables :(
-declare 234 generic {
+declare 234 {
     Var *TclVarHashCreateVar(TclVarHashTable *tablePtr, const char *key,
              int *newPtr)
 }
-declare 235 generic {
+declare 235 {
     void TclInitVarHashTable(TclVarHashTable *tablePtr, Namespace *nsPtr)
 }
 
 
 # TIP 337 made this one public
-#declare 236 generic {
+#declare 236 {
 #    void TclBackgroundException(Tcl_Interp *interp, int code)
 #}
 
 # TIP #285: Script cancellation support.
-declare 237 generic {
+declare 237 {
     int TclResetCancellation(Tcl_Interp *interp, int force)
 }
 
 # NRE functions for "rogue" extensions to exploit NRE; they will need to
 # include NRE.h too.
-declare 238 generic {
+declare 238 {
     int TclNRInterpProc(ClientData clientData, Tcl_Interp *interp,
 	    int objc, Tcl_Obj *const objv[])
 }
-declare 239 generic {
+declare 239 {
     int TclNRInterpProcCore(Tcl_Interp *interp, Tcl_Obj *procNameObj,
 			    int skip, ProcErrorProc *errorProc)
 }
-declare 240 generic {
+declare 240 {
     int TclNRRunCallbacks(Tcl_Interp *interp, int result,
 	      struct TEOV_callback *rootPtr, int tebcCall)
 }
-declare 241 generic {
+declare 241 {
     int TclNREvalObjEx(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags,
 	    const CmdFrame *invoker, int word)
 }
-declare 242 generic {
+declare 242 {
     int TclNREvalObjv(Tcl_Interp *interp, int objc,
 	      Tcl_Obj *const objv[], int flags, Command *cmdPtr)
 }
 
 # Tcl_Obj leak detection support.
-declare 243 generic {
+declare 243 {
     void TclDbDumpActiveObjects(FILE *outFile)
 }
 
 # Functions to make things better for itcl
-declare 244 generic {
+declare 244 {
     Tcl_HashTable *TclGetNamespaceChildTable(Tcl_Namespace *nsPtr)
 }
-declare 245 generic {
+declare 245 {
     Tcl_HashTable *TclGetNamespaceCommandTable(Tcl_Namespace *nsPtr)
 }
-declare 246 generic {
+declare 246 {
     int TclInitRewriteEnsemble(Tcl_Interp *interp, int numRemoved,
 	    int numInserted, Tcl_Obj *const *objv)
 }
-declare 247 generic {
+declare 247 {
     void TclResetRewriteEnsemble(Tcl_Interp *interp, int isRootEnsemble)
 }
 
-declare 248 generic {
+declare 248 {
     int TclCopyChannel(Tcl_Interp *interp, Tcl_Channel inChan,
 	    Tcl_Channel outChan, Tcl_WideInt toRead, Tcl_Obj *cmdPtr)
 }
@@ -1097,7 +1098,7 @@ declare 23 win {
 declare 24 win {
     char *TclWinNoBackslash(char *path)
 }
-# replaced by generic TclGetPlatform
+# replaced by TclGetPlatform
 #declare 25 win {
 #    TclPlatformType *TclWinGetPlatform(void)
 #}
@@ -1169,7 +1170,7 @@ declare 10 unix {
     Tcl_DirEntry *TclpReaddir(DIR *dir)
 }
 # Slots 11 and 12 are forwarders for functions that were promoted to
-# generic Stubs
+# Stubs
 declare 11 unix {
     struct tm *TclpLocaltime_unix(const time_t *clock)
 }
diff --git a/generic/tclOO.decls b/generic/tclOO.decls
index f334103..80b4eff 100644
--- a/generic/tclOO.decls
+++ b/generic/tclOO.decls
@@ -1,4 +1,4 @@
-# $Id: tclOO.decls,v 1.7 2010/03/05 15:32:16 dkf Exp $
+# $Id: tclOO.decls,v 1.8 2010/09/15 07:33:54 nijtmans Exp $
 
 library tclOO
 
@@ -8,111 +8,112 @@ library tclOO
 
 interface tclOO
 hooks tclOOInt
+scspec EXTERN
 
-declare 0 generic {
+declare 0 {
     Tcl_Object Tcl_CopyObjectInstance(Tcl_Interp *interp,
 	    Tcl_Object sourceObject, const char *targetName,
 	    const char *targetNamespaceName)
 }
-declare 1 generic {
+declare 1 {
     Tcl_Object Tcl_GetClassAsObject(Tcl_Class clazz)
 }
-declare 2 generic {
+declare 2 {
     Tcl_Class Tcl_GetObjectAsClass(Tcl_Object object)
 }
-declare 3 generic {
+declare 3 {
     Tcl_Command Tcl_GetObjectCommand(Tcl_Object object)
 }
-declare 4 generic {
+declare 4 {
     Tcl_Object Tcl_GetObjectFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr)
 }
-declare 5 generic {
+declare 5 {
     Tcl_Namespace *Tcl_GetObjectNamespace(Tcl_Object object)
 }
-declare 6 generic {
+declare 6 {
     Tcl_Class Tcl_MethodDeclarerClass(Tcl_Method method)
 }
-declare 7 generic {
+declare 7 {
     Tcl_Object Tcl_MethodDeclarerObject(Tcl_Method method)
 }
-declare 8 generic {
+declare 8 {
     int Tcl_MethodIsPublic(Tcl_Method method)
 }
-declare 9 generic {
+declare 9 {
     int Tcl_MethodIsType(Tcl_Method method, const Tcl_MethodType *typePtr,
 	    ClientData *clientDataPtr)
 }
-declare 10 generic {
+declare 10 {
     Tcl_Obj *Tcl_MethodName(Tcl_Method method)
 }
-declare 11 generic {
+declare 11 {
     Tcl_Method Tcl_NewInstanceMethod(Tcl_Interp *interp, Tcl_Object object,
 	    Tcl_Obj *nameObj, int isPublic, const Tcl_MethodType *typePtr,
 	    ClientData clientData)
 }
-declare 12 generic {
+declare 12 {
     Tcl_Method Tcl_NewMethod(Tcl_Interp *interp, Tcl_Class cls,
 	    Tcl_Obj *nameObj, int isPublic, const Tcl_MethodType *typePtr,
 	    ClientData clientData)
 }
-declare 13 generic {
+declare 13 {
     Tcl_Object Tcl_NewObjectInstance(Tcl_Interp *interp, Tcl_Class cls,
 	    const char *nameStr, const char *nsNameStr, int objc,
 	    Tcl_Obj *const *objv, int skip)
 }
-declare 14 generic {
+declare 14 {
     int Tcl_ObjectDeleted(Tcl_Object object)
 }
-declare 15 generic {
+declare 15 {
     int Tcl_ObjectContextIsFiltering(Tcl_ObjectContext context)
 }
-declare 16 generic {
+declare 16 {
     Tcl_Method Tcl_ObjectContextMethod(Tcl_ObjectContext context)
 }
-declare 17 generic {
+declare 17 {
     Tcl_Object Tcl_ObjectContextObject(Tcl_ObjectContext context)
 }
-declare 18 generic {
+declare 18 {
     int Tcl_ObjectContextSkippedArgs(Tcl_ObjectContext context)
 }
-declare 19 generic {
+declare 19 {
     ClientData Tcl_ClassGetMetadata(Tcl_Class clazz,
 	    const Tcl_ObjectMetadataType *typePtr)
 }
-declare 20 generic {
+declare 20 {
     void Tcl_ClassSetMetadata(Tcl_Class clazz,
 	    const Tcl_ObjectMetadataType *typePtr, ClientData metadata)
 }
-declare 21 generic {
+declare 21 {
     ClientData Tcl_ObjectGetMetadata(Tcl_Object object,
 	    const Tcl_ObjectMetadataType *typePtr)
 }
-declare 22 generic {
+declare 22 {
     void Tcl_ObjectSetMetadata(Tcl_Object object,
 	    const Tcl_ObjectMetadataType *typePtr, ClientData metadata)
 }
-declare 23 generic {
+declare 23 {
     int Tcl_ObjectContextInvokeNext(Tcl_Interp *interp,
 	    Tcl_ObjectContext context, int objc, Tcl_Obj *const *objv,
 	    int skip)
 }
-declare 24 generic {
+declare 24 {
     Tcl_ObjectMapMethodNameProc *Tcl_ObjectGetMethodNameMapper(
 	    Tcl_Object object)
 }
-declare 25 generic {
+declare 25 {
     void Tcl_ObjectSetMethodNameMapper(Tcl_Object object,
 	    Tcl_ObjectMapMethodNameProc *mapMethodNameProc)
 }
-declare 26 generic {
+declare 26 {
     void Tcl_ClassSetConstructor(Tcl_Interp *interp, Tcl_Class clazz,
 	    Tcl_Method method)
 }
-declare 27 generic {
+declare 27 {
     void Tcl_ClassSetDestructor(Tcl_Interp *interp, Tcl_Class clazz,
 	    Tcl_Method method)
 }
-declare 28 generic {
+declare 28 {
     Tcl_Obj *Tcl_GetObjectName(Tcl_Interp *interp, Tcl_Object object)
 }
 
@@ -122,78 +123,78 @@ declare 28 generic {
 
 interface tclOOInt
 
-declare 0 generic {
+declare 0 {
     Tcl_Object TclOOGetDefineCmdContext(Tcl_Interp *interp)
 }
-declare 1 generic {
+declare 1 {
     Tcl_Method TclOOMakeProcInstanceMethod(Tcl_Interp *interp, Object *oPtr,
 	    int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj,
 	    const Tcl_MethodType *typePtr, ClientData clientData,
 	    Proc **procPtrPtr)
 }
-declare 2 generic {
+declare 2 {
     Tcl_Method TclOOMakeProcMethod(Tcl_Interp *interp, Class *clsPtr,
 	    int flags, Tcl_Obj *nameObj, const char *namePtr,
 	    Tcl_Obj *argsObj, Tcl_Obj *bodyObj, const Tcl_MethodType *typePtr,
 	    ClientData clientData, Proc **procPtrPtr)
 }
-declare 3 generic {
+declare 3 {
     Method *TclOONewProcInstanceMethod(Tcl_Interp *interp, Object *oPtr,
 	    int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj,
 	    ProcedureMethod **pmPtrPtr)
 }
-declare 4 generic {
+declare 4 {
     Method *TclOONewProcMethod(Tcl_Interp *interp, Class *clsPtr,
 	    int flags, Tcl_Obj *nameObj, Tcl_Obj *argsObj, Tcl_Obj *bodyObj,
 	    ProcedureMethod **pmPtrPtr)
 }
-declare 5 generic {
+declare 5 {
     int TclOOObjectCmdCore(Object *oPtr, Tcl_Interp *interp, int objc,
 	    Tcl_Obj *const *objv, int publicOnly, Class *startCls)
 }
-declare 6 generic {
+declare 6 {
     int TclOOIsReachable(Class *targetPtr, Class *startPtr)
 }
-declare 7 generic {
+declare 7 {
     Method *TclOONewForwardMethod(Tcl_Interp *interp, Class *clsPtr,
 	    int isPublic, Tcl_Obj *nameObj, Tcl_Obj *prefixObj)
 }
-declare 8 generic {
+declare 8 {
     Method *TclOONewForwardInstanceMethod(Tcl_Interp *interp, Object *oPtr,
 	    int isPublic, Tcl_Obj *nameObj, Tcl_Obj *prefixObj)
 }
-declare 9 generic {
+declare 9 {
     Tcl_Method TclOONewProcInstanceMethodEx(Tcl_Interp *interp,
 	    Tcl_Object oPtr, TclOO_PreCallProc *preCallPtr,
 	    TclOO_PostCallProc *postCallPtr, ProcErrorProc *errProc,
 	    ClientData clientData, Tcl_Obj *nameObj, Tcl_Obj *argsObj,
 	    Tcl_Obj *bodyObj, int flags, void **internalTokenPtr)
 }
-declare 10 generic {
+declare 10 {
     Tcl_Method TclOONewProcMethodEx(Tcl_Interp *interp, Tcl_Class clsPtr,
 	    TclOO_PreCallProc *preCallPtr, TclOO_PostCallProc *postCallPtr,
 	    ProcErrorProc *errProc, ClientData clientData, Tcl_Obj *nameObj,
 	    Tcl_Obj *argsObj, Tcl_Obj *bodyObj, int flags,
 	    void **internalTokenPtr)
 }
-declare 11 generic {
+declare 11 {
     int TclOOInvokeObject(Tcl_Interp *interp, Tcl_Object object,
 	    Tcl_Class startCls, int publicPrivate, int objc,
 	    Tcl_Obj *const *objv)
 }
-declare 12 generic {
+declare 12 {
     void TclOOObjectSetFilters(Object *oPtr, int numFilters,
 	    Tcl_Obj *const *filters)
 }
-declare 13 generic {
+declare 13 {
     void TclOOClassSetFilters(Tcl_Interp *interp, Class *classPtr,
 	    int numFilters, Tcl_Obj *const *filters)
 }
-declare 14 generic {
+declare 14 {
     void TclOOObjectSetMixins(Object *oPtr, int numMixins,
 	    Class *const *mixins)
 }
-declare 15 generic {
+declare 15 {
     void TclOOClassSetMixins(Tcl_Interp *interp, Class *classPtr,
 	    int numMixins, Class *const *mixins)
 }
diff --git a/generic/tclTomMath.decls b/generic/tclTomMath.decls
index 2721c1d..12fa7cd 100644
--- a/generic/tclTomMath.decls
+++ b/generic/tclTomMath.decls
@@ -13,7 +13,7 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #
-# RCS: @(#) $Id: tclTomMath.decls,v 1.7 2010/05/03 14:36:40 nijtmans Exp $
+# RCS: @(#) $Id: tclTomMath.decls,v 1.8 2010/09/15 07:33:54 nijtmans Exp $
 
 library tcl
 
@@ -21,195 +21,196 @@ library tcl
 
 interface tclTomMath
 # hooks {tclTomMathInt}
+scspec EXTERN
 
 # Declare each of the functions in the Tcl tommath interface
 
-declare 0 generic {
+declare 0 {
     int TclBN_epoch(void)
 }
-declare 1 generic {
+declare 1 {
     int TclBN_revision(void)
 }
 
-declare 2 generic {
+declare 2 {
     int TclBN_mp_add(mp_int *a, mp_int *b, mp_int *c)
 }
-declare 3 generic {
+declare 3 {
     int TclBN_mp_add_d(mp_int *a, mp_digit b, mp_int *c)
 }
-declare 4 generic {
+declare 4 {
     int TclBN_mp_and(mp_int *a, mp_int *b, mp_int *c)
 }
-declare 5 generic {
+declare 5 {
     void TclBN_mp_clamp(mp_int *a)
 }
-declare 6 generic {
+declare 6 {
     void TclBN_mp_clear(mp_int *a)
 }
-declare 7 generic {
+declare 7 {
     void TclBN_mp_clear_multi(mp_int *a, ...)
 }
-declare 8 generic {
+declare 8 {
     int TclBN_mp_cmp(const mp_int *a, const mp_int *b)
 }
-declare 9 generic {
+declare 9 {
     int TclBN_mp_cmp_d(const mp_int *a, mp_digit b)
 }
-declare 10 generic {
+declare 10 {
     int TclBN_mp_cmp_mag(const mp_int *a, const mp_int *b)
 }
-declare 11 generic {
+declare 11 {
     int TclBN_mp_copy(const mp_int *a, mp_int *b)
 }
-declare 12 generic {
+declare 12 {
     int TclBN_mp_count_bits(const mp_int *a)
 }
-declare 13 generic {
+declare 13 {
     int TclBN_mp_div(mp_int *a, mp_int *b, mp_int *q, mp_int *r)
 }
-declare 14 generic {
+declare 14 {
     int TclBN_mp_div_d(mp_int *a, mp_digit b, mp_int *q, mp_digit *r)
 }
-declare 15 generic {
+declare 15 {
     int TclBN_mp_div_2(mp_int *a, mp_int *q)
 }
-declare 16 generic {
+declare 16 {
     int TclBN_mp_div_2d(const mp_int *a, int b, mp_int *q, mp_int *r)
 }
-declare 17 generic {
+declare 17 {
     int TclBN_mp_div_3(mp_int *a, mp_int *q, mp_digit *r)
 }
-declare 18 generic {
+declare 18 {
     void TclBN_mp_exch(mp_int *a, mp_int *b)
 }
-declare 19 generic {
+declare 19 {
     int TclBN_mp_expt_d(mp_int *a, mp_digit b, mp_int *c)
 }
-declare 20 generic {
+declare 20 {
     int TclBN_mp_grow(mp_int *a, int size)
 }
-declare 21 generic {
+declare 21 {
     int TclBN_mp_init(mp_int *a)
 }
-declare 22 generic {
+declare 22 {
     int TclBN_mp_init_copy(mp_int *a, mp_int *b)
 }
-declare 23 generic {
+declare 23 {
     int TclBN_mp_init_multi(mp_int *a, ...)
 }
-declare 24 generic {
+declare 24 {
     int TclBN_mp_init_set(mp_int *a, mp_digit b)
 }
-declare 25 generic {
+declare 25 {
     int TclBN_mp_init_size(mp_int *a, int size)
 }
-declare 26 generic {
+declare 26 {
     int TclBN_mp_lshd(mp_int *a, int shift)
 }
-declare 27 generic {
+declare 27 {
     int TclBN_mp_mod(mp_int *a, mp_int *b, mp_int *r)
 }
-declare 28 generic {
+declare 28 {
     int TclBN_mp_mod_2d(const mp_int *a, int b, mp_int *r)
 }
-declare 29 generic {
+declare 29 {
     int TclBN_mp_mul(mp_int *a, mp_int *b, mp_int *p)
 }
-declare 30 generic {
+declare 30 {
     int TclBN_mp_mul_d(mp_int *a, mp_digit b, mp_int *p)
 }
-declare 31 generic {
+declare 31 {
     int TclBN_mp_mul_2(mp_int *a, mp_int *p)
 }
-declare 32 generic {
+declare 32 {
     int TclBN_mp_mul_2d(const mp_int *a, int d, mp_int *p)
 }
-declare 33 generic {
+declare 33 {
     int TclBN_mp_neg(const mp_int *a, mp_int *b)
 }
-declare 34 generic {
+declare 34 {
     int TclBN_mp_or(mp_int *a, mp_int *b, mp_int *c)
 }
-declare 35 generic {
+declare 35 {
     int TclBN_mp_radix_size(mp_int *a, int radix, int *size)
 }
-declare 36 generic {
+declare 36 {
     int TclBN_mp_read_radix(mp_int *a, const char *str, int radix)
 }
-declare 37 generic {
+declare 37 {
     void TclBN_mp_rshd(mp_int *a, int shift)
 }
-declare 38 generic {
+declare 38 {
     int TclBN_mp_shrink(mp_int *a)
 }
-declare 39 generic {
+declare 39 {
     void TclBN_mp_set(mp_int *a, mp_digit b)
 }
-declare 40 generic {
+declare 40 {
     int TclBN_mp_sqr(mp_int *a, mp_int *b)
 }
-declare 41 generic {
+declare 41 {
     int TclBN_mp_sqrt(mp_int *a, mp_int *b)
 }
-declare 42 generic {
+declare 42 {
     int TclBN_mp_sub(mp_int *a, mp_int *b, mp_int *c)
 }
-declare 43 generic {
+declare 43 {
     int TclBN_mp_sub_d(mp_int *a, mp_digit b, mp_int *c)
 }
-declare 44 generic {
+declare 44 {
     int TclBN_mp_to_unsigned_bin(mp_int *a, unsigned char *b)
 }
-declare 45 generic {
+declare 45 {
     int TclBN_mp_to_unsigned_bin_n(mp_int *a, unsigned char *b,
 	    unsigned long *outlen)
 }
-declare 46 generic {
+declare 46 {
     int TclBN_mp_toradix_n(mp_int *a, char *str, int radix, int maxlen)
 }
-declare 47 generic {
+declare 47 {
     int TclBN_mp_unsigned_bin_size(mp_int *a)
 }
-declare 48 generic {
+declare 48 {
     int TclBN_mp_xor(mp_int *a, mp_int *b, mp_int *c)
 }
-declare 49 generic {
+declare 49 {
     void TclBN_mp_zero(mp_int *a)
 }
 
 # internal routines to libtommath - should not be called but must be
 # exported to accommodate the "tommath" extension
 
-declare 50 generic {
+declare 50 {
     void TclBN_reverse(unsigned char *s, int len)
 }
-declare 51 generic {
+declare 51 {
     int TclBN_fast_s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs)
 }
-declare 52 generic {
+declare 52 {
     int TclBN_fast_s_mp_sqr(mp_int *a, mp_int *b)
 }
-declare 53 generic {
+declare 53 {
     int TclBN_mp_karatsuba_mul(mp_int *a, mp_int *b, mp_int *c)
 }
-declare 54 generic {
+declare 54 {
     int TclBN_mp_karatsuba_sqr(mp_int *a, mp_int *b)
 }
-declare 55 generic {
+declare 55 {
     int TclBN_mp_toom_mul(mp_int *a, mp_int *b, mp_int *c)
 }
-declare 56 generic {
+declare 56 {
     int TclBN_mp_toom_sqr(mp_int *a, mp_int *b)
 }
-declare 57 generic {
+declare 57 {
     int TclBN_s_mp_add(mp_int *a, mp_int *b, mp_int *c)
 }
-declare 58 generic {
+declare 58 {
     int TclBN_s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs)
 }
-declare 59 generic {
+declare 59 {
     int TclBN_s_mp_sqr(mp_int *a, mp_int *b)
 }
-declare 60 generic {
+declare 60 {
     int TclBN_s_mp_sub(mp_int *a, mp_int *b, mp_int *c)
 }
diff --git a/tools/genStubs.tcl b/tools/genStubs.tcl
index 81752d6..3e896a1 100644
--- a/tools/genStubs.tcl
+++ b/tools/genStubs.tcl
@@ -10,7 +10,7 @@
 # See the file "license.terms" for information on usage and redistribution
 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 #
-# RCS: @(#) $Id: genStubs.tcl,v 1.43 2010/09/13 21:17:03 nijtmans Exp $
+# RCS: @(#) $Id: genStubs.tcl,v 1.44 2010/09/15 07:33:56 nijtmans Exp $
 
 package require Tcl 8.4
 
@@ -42,6 +42,15 @@ namespace eval genStubs {
     #
     variable scspec "EXTERN"
 
+    # epoch, revision --
+    #
+    #	The epoch and revision numbers of the interface currently being defined.
+    #   (@@@TODO: should be an array mapping interface names -> numbers)
+    #
+
+    variable epoch {}
+    variable revision 0
+
     # hooks --
     #
     #	An array indexed by interface name that contains the set of
@@ -114,6 +123,16 @@ proc genStubs::scspec {value} {
     variable scspec $value
 }
 
+# genStubs::epoch --
+#
+#	Define the epoch number for this library.  The epoch
+#	should be incrememented when a release is made that
+#	contains incompatible changes to the public API.
+#
+proc genStubs::epoch {value} {
+    variable epoch $value
+}
+
 # genStubs::hooks --
 #
 #	This function defines the subinterface hooks for the current
@@ -152,12 +171,18 @@ proc genStubs::hooks {names} {
 proc genStubs::declare {args} {
     variable stubs
     variable curName
-
-    if {[llength $args] != 3} {
+    variable revision
+
+    incr revision
+    if {[llength $args] == 2} {
+	lassign $args index decl
+	set platformList generic
+    } elseif {[llength $args] == 3} {
+	lassign $args index platformList decl
+    } else {
 	puts stderr "wrong # args: declare $args"
 	return
     }
-    lassign $args index platformList decl
 
     # Check for duplicate declarations, then add the declaration and
     # bump the lastNum counter if necessary.
@@ -929,10 +954,19 @@ proc genStubs::emitMacros {name textVar} {
 proc genStubs::emitHeader {name} {
     variable outDir
     variable hooks
+    variable epoch
+    variable revision
 
     set capName [string toupper [string index $name 0]]
     append capName [string range $name 1 end]
 
+    if {$epoch ne ""} {
+	set CAPName [string toupper $name]
+	append text "\n"
+	append text "#define ${CAPName}_STUBS_EPOCH $epoch\n"
+	append text "#define ${CAPName}_STUBS_REVISION $revision\n"
+    }
+
     emitDeclarations $name text
 
     if {[info exists hooks($name)]} {
@@ -946,6 +980,10 @@ proc genStubs::emitHeader {name} {
     }
     append text "\ntypedef struct ${capName}Stubs {\n"
     append text "    int magic;\n"
+    if {$epoch ne ""} {
+	append text "    int epoch;\n"
+	append text "    int revision;\n"
+    }
     append text "    const struct ${capName}StubHooks *hooks;\n\n"
 
     emitSlots $name text
@@ -976,6 +1014,7 @@ proc genStubs::emitHeader {name} {
 proc genStubs::emitInit {name textVar} {
     variable hooks
     variable interfaces
+    variable epoch
     upvar $textVar text
     set root 1
 
@@ -1005,6 +1044,11 @@ proc genStubs::emitInit {name textVar} {
 	append text "static "
     }
     append text "const ${capName}Stubs ${name}Stubs = \{\n    TCL_STUB_MAGIC,\n"
+    if {$epoch ne ""} {
+	set CAPName [string toupper $name]
+	append text "    ${CAPName}_STUBS_EPOCH,\n"
+	append text "    ${CAPName}_STUBS_REVISION,\n"
+    }
     if {[info exists hooks($name)]} {
 	append text "    &${name}StubHooks,\n"
     } else {
-- 
cgit v0.12