Tcl Source Code

Check-in [adb44e19f5]
Login
Bounty program for improvements to Tcl and certain Tcl packages.
Tcl 2019 Conference, Houston/TX, US, Nov 4-8
Send your abstracts to [email protected]
or submit via the online form by Sep 9.

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Remove the stub function definitions. Change stub macros to use just the name of the function without any parameters (to be able to get the address of a function).

Changed passing of tclStubsPtr to the interp (during Tcl_CreateInterp) to pass &tclStubs to avoid problems with duplicate symbols on Solaris.

Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | core-8-1-branch-old
Files: files | file ages | folders
SHA1: adb44e19f531e8fe66b4a1ac661b9bb9f007a473
User & Date: redman 1999-03-30 01:55:49
Context
1999-03-30
02:29
Remove the stubs functions, corrected the stub .obj file set. check-in: b436652040 user: redman tags: core-8-1-branch-old
01:55
Remove the stub function definitions. Change stub macros to use just the name of the function witho... check-in: adb44e19f5 user: redman tags: core-8-1-branch-old
1999-03-27
23:25
Fixed Bug IDs 1517, 1520, 1579. check-in: 14c1af0b4d user: redman tags: core-8-1-branch-old
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Changes to generic/tcl.h.

     8      8    * Copyright (c) 1993-1996 Lucent Technologies.
     9      9    * Copyright (c) 1994-1998 Sun Microsystems, Inc.
    10     10    * Copyright (c) 1998-1999 by Scriptics Corporation.
    11     11    *
    12     12    * See the file "license.terms" for information on usage and redistribution
    13     13    * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
    14     14    *
    15         - * RCS: @(#) $Id: tcl.h,v 1.1.2.19 1999/03/17 21:29:57 stanton Exp $
           15  + * RCS: @(#) $Id: tcl.h,v 1.1.2.20 1999/03/30 01:55:49 redman Exp $
    16     16    */
    17     17   
    18     18   #ifndef _TCL
    19     19   #define _TCL
    20     20   
    21     21   /*
    22     22    * The following defines are used to indicate the various release levels.
................................................................................
  1301   1301   /*
  1302   1302    * The following function is required to be defined in all stubs aware
  1303   1303    * extensions.  The function is actually implemented in the stub
  1304   1304    * library, not the main Tcl library, although there is a trivial
  1305   1305    * implementation in the main library in case an extension is statically
  1306   1306    * linked into an application.
  1307   1307    */
         1308  +
         1309  +#ifdef USE_TCL_STUBS
  1308   1310   
  1309   1311   EXTERN char *		Tcl_InitStubs _ANSI_ARGS_((Tcl_Interp *interp,
  1310   1312   			    char *version, int exact));
         1313  +
         1314  +#else
         1315  +
         1316  +/*
         1317  + * When not using stubs, make it a macro.
         1318  + */
         1319  +
         1320  +#define Tcl_InitStubs(interp, version, exact) \
         1321  +    Tcl_PkgRequire(interp, "Tcl", version, exact)
         1322  +
         1323  +#endif
         1324  +
  1311   1325   
  1312   1326   /*
  1313   1327    * Include the public function declarations that are accessible via
  1314   1328    * the stubs table.
  1315   1329    */
  1316   1330   
  1317   1331   #include "tclDecls.h"

Changes to generic/tclBasic.c.

     8      8    * Copyright (c) 1987-1994 The Regents of the University of California.
     9      9    * Copyright (c) 1994-1997 Sun Microsystems, Inc.
    10     10    * Copyright (c) 1998-1999 by Scriptics Corporation.
    11     11    *
    12     12    * See the file "license.terms" for information on usage and redistribution
    13     13    * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
    14     14    *
    15         - * RCS: @(#) $Id: tclBasic.c,v 1.1.2.11 1999/03/11 01:50:28 stanton Exp $
           15  + * RCS: @(#) $Id: tclBasic.c,v 1.1.2.12 1999/03/30 01:55:50 redman Exp $
    16     16    */
    17     17   
    18     18   #include "tclInt.h"
    19     19   #include "tclCompile.h"
    20     20   #ifndef TCL_GENERIC_ONLY
    21     21   #   include "tclPort.h"
    22     22   #endif
................................................................................
    27     27   
    28     28   static void		DeleteInterpProc _ANSI_ARGS_((Tcl_Interp *interp));
    29     29   static void		ProcessUnexpectedResult _ANSI_ARGS_((
    30     30   			    Tcl_Interp *interp, int returnCode));
    31     31   static void		RecordTracebackInfo _ANSI_ARGS_((
    32     32   			    Tcl_Interp *interp, Tcl_Obj *objPtr,
    33     33   			    int numSrcBytes));
           34  +
           35  +extern TclStubs tclStubs;
    34     36   
    35     37   /*
    36     38    * The following structure defines the commands in the Tcl core.
    37     39    */
    38     40   
    39     41   typedef struct {
    40     42       char *name;			/* Name of object-based command. */
................................................................................
   232    234           (CompileProc *) NULL,		0},
   233    235   #endif /* MAC_TCL */
   234    236       
   235    237   #endif /* TCL_GENERIC_ONLY */
   236    238       {NULL,		(Tcl_CmdProc *) NULL,	(Tcl_ObjCmdProc *) NULL,
   237    239           (CompileProc *) NULL,		0}
   238    240   };
   239         -
   240         -/*
   241         - *----------------------------------------------------------------------
   242         - *
   243         - * Tcl_InitStubs --
   244         - *
   245         - *	Ensures that the correct version of Tcl is loaded.  This is
   246         - *	a trivial implementation of the stubs library initializer
   247         - *	that will get called if a stubs aware extension is directly
   248         - *	linked with the Tcl library.
   249         - *
   250         - * Results:
   251         - *	The actual version of Tcl that satisfies the request, or
   252         - *	NULL to indicate that an error occurred.
   253         - *
   254         - * Side effects:
   255         - *	None.
   256         - *
   257         - *----------------------------------------------------------------------
   258         - */
   259    241   
   260         -char *
   261         -Tcl_InitStubs (interp, version, exact)
   262         -    Tcl_Interp *interp;
   263         -    char *version;
   264         -    int exact;
   265         -{
   266         -    return Tcl_PkgRequire(interp, "Tcl", version, exact);
   267         -}
   268    242   
   269    243   /*
   270    244    *----------------------------------------------------------------------
   271    245    *
   272    246    * Tcl_CreateInterp --
   273    247    *
   274    248    *	Create a new TCL command interpreter.
................................................................................
   424    398               sizeof(statsPtr->literalCount));
   425    399   #endif /* TCL_COMPILE_STATS */    
   426    400   
   427    401       /*
   428    402        * Initialise the stub table pointer.
   429    403        */
   430    404   
   431         -    iPtr->stubTable = tclStubsPtr;
          405  +    iPtr->stubTable = &tclStubs;
   432    406       
   433    407       /*
   434    408        * Create the core commands. Do it here, rather than calling
   435    409        * Tcl_CreateCommand, because it's faster (there's no need to check for
   436    410        * a pre-existing command by the same name). If a command has a
   437    411        * Tcl_CmdProc but no Tcl_ObjCmdProc, set the Tcl_ObjCmdProc to
   438    412        * TclInvokeStringCommand. This is an object-based wrapper procedure
................................................................................
   559    533   	    TclPrecTraceProc, (ClientData) NULL);
   560    534       TclpSetVariables(interp);
   561    535   
   562    536       /*
   563    537        * Register Tcl's version number.
   564    538        */
   565    539   
   566         -    Tcl_PkgProvideEx(interp, "Tcl", TCL_VERSION, (ClientData) tclStubsPtr);
          540  +    Tcl_PkgProvideEx(interp, "Tcl", TCL_VERSION, (ClientData) &tclStubs);
   567    541       
   568    542       return interp;
   569    543   }
   570    544   
   571    545   /*
   572    546    *----------------------------------------------------------------------
   573    547    *

Changes to generic/tclDecls.h.

     4      4    *	Declarations of functions in the platform independent public Tcl API.
     5      5    *
     6      6    * Copyright (c) 1998-1999 by Scriptics Corporation.
     7      7    *
     8      8    * See the file "license.terms" for information on usage and redistribution
     9      9    * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
    10     10    *
    11         - * RCS: @(#) $Id: tclDecls.h,v 1.3.2.9 1999/03/24 04:25:12 stanton Exp $
           11  + * RCS: @(#) $Id: tclDecls.h,v 1.3.2.10 1999/03/30 01:55:51 redman Exp $
    12     12    */
    13     13   
    14     14   #ifndef _TCLDECLS
    15     15   #define _TCLDECLS
    16     16   
    17     17   /*
    18     18    * WARNING: This file is automatically generated by the tools/genStubs.tcl
................................................................................
  1438   1438   #if defined(USE_TCL_STUBS) && !defined(USE_TCL_STUB_PROCS)
  1439   1439   
  1440   1440   /*
  1441   1441    * Inline function declarations:
  1442   1442    */
  1443   1443   
  1444   1444   #ifndef Tcl_PkgProvideEx
  1445         -#define Tcl_PkgProvideEx(interp, name, version, clientData) \
  1446         -	(tclStubsPtr->tcl_PkgProvideEx)(interp, name, version, clientData) /* 0 */
         1445  +#define Tcl_PkgProvideEx \
         1446  +	(tclStubsPtr->tcl_PkgProvideEx) /* 0 */
  1447   1447   #endif
  1448   1448   #ifndef Tcl_PkgRequireEx
  1449         -#define Tcl_PkgRequireEx(interp, name, version, exact, clientDataPtr) \
  1450         -	(tclStubsPtr->tcl_PkgRequireEx)(interp, name, version, exact, clientDataPtr) /* 1 */
         1449  +#define Tcl_PkgRequireEx \
         1450  +	(tclStubsPtr->tcl_PkgRequireEx) /* 1 */
  1451   1451   #endif
  1452   1452   #ifndef Tcl_Panic
  1453   1453   #define Tcl_Panic \
  1454   1454   	(tclStubsPtr->tcl_Panic) /* 2 */
  1455   1455   #endif
  1456   1456   #ifndef Tcl_Alloc
  1457         -#define Tcl_Alloc(size) \
  1458         -	(tclStubsPtr->tcl_Alloc)(size) /* 3 */
         1457  +#define Tcl_Alloc \
         1458  +	(tclStubsPtr->tcl_Alloc) /* 3 */
  1459   1459   #endif
  1460   1460   #ifndef Tcl_Free
  1461         -#define Tcl_Free(ptr) \
  1462         -	(tclStubsPtr->tcl_Free)(ptr) /* 4 */
         1461  +#define Tcl_Free \
         1462  +	(tclStubsPtr->tcl_Free) /* 4 */
  1463   1463   #endif
  1464   1464   #ifndef Tcl_Realloc
  1465         -#define Tcl_Realloc(ptr, size) \
  1466         -	(tclStubsPtr->tcl_Realloc)(ptr, size) /* 5 */
         1465  +#define Tcl_Realloc \
         1466  +	(tclStubsPtr->tcl_Realloc) /* 5 */
  1467   1467   #endif
  1468   1468   #ifndef Tcl_DbCkalloc
  1469         -#define Tcl_DbCkalloc(size, file, line) \
  1470         -	(tclStubsPtr->tcl_DbCkalloc)(size, file, line) /* 6 */
         1469  +#define Tcl_DbCkalloc \
         1470  +	(tclStubsPtr->tcl_DbCkalloc) /* 6 */
  1471   1471   #endif
  1472   1472   #ifndef Tcl_DbCkfree
  1473         -#define Tcl_DbCkfree(ptr, file, line) \
  1474         -	(tclStubsPtr->tcl_DbCkfree)(ptr, file, line) /* 7 */
         1473  +#define Tcl_DbCkfree \
         1474  +	(tclStubsPtr->tcl_DbCkfree) /* 7 */
  1475   1475   #endif
  1476   1476   #ifndef Tcl_DbCkrealloc
  1477         -#define Tcl_DbCkrealloc(ptr, size, file, line) \
  1478         -	(tclStubsPtr->tcl_DbCkrealloc)(ptr, size, file, line) /* 8 */
         1477  +#define Tcl_DbCkrealloc \
         1478  +	(tclStubsPtr->tcl_DbCkrealloc) /* 8 */
  1479   1479   #endif
  1480   1480   #if !defined(__WIN32__) && !defined(MAC_TCL) /* UNIX */
  1481   1481   #ifndef Tcl_CreateFileHandler
  1482         -#define Tcl_CreateFileHandler(fd, mask, proc, clientData) \
  1483         -	(tclStubsPtr->tcl_CreateFileHandler)(fd, mask, proc, clientData) /* 9 */
         1482  +#define Tcl_CreateFileHandler \
         1483  +	(tclStubsPtr->tcl_CreateFileHandler) /* 9 */
  1484   1484   #endif
  1485   1485   #endif /* UNIX */
  1486   1486   #if !defined(__WIN32__) && !defined(MAC_TCL) /* UNIX */
  1487   1487   #ifndef Tcl_DeleteFileHandler
  1488         -#define Tcl_DeleteFileHandler(fd) \
  1489         -	(tclStubsPtr->tcl_DeleteFileHandler)(fd) /* 10 */
         1488  +#define Tcl_DeleteFileHandler \
         1489  +	(tclStubsPtr->tcl_DeleteFileHandler) /* 10 */
  1490   1490   #endif
  1491   1491   #endif /* UNIX */
  1492   1492   #ifndef Tcl_SetTimer
  1493         -#define Tcl_SetTimer(timePtr) \
  1494         -	(tclStubsPtr->tcl_SetTimer)(timePtr) /* 11 */
         1493  +#define Tcl_SetTimer \
         1494  +	(tclStubsPtr->tcl_SetTimer) /* 11 */
  1495   1495   #endif
  1496   1496   #ifndef Tcl_Sleep
  1497         -#define Tcl_Sleep(ms) \
  1498         -	(tclStubsPtr->tcl_Sleep)(ms) /* 12 */
         1497  +#define Tcl_Sleep \
         1498  +	(tclStubsPtr->tcl_Sleep) /* 12 */
  1499   1499   #endif
  1500   1500   #ifndef Tcl_WaitForEvent
  1501         -#define Tcl_WaitForEvent(timePtr) \
  1502         -	(tclStubsPtr->tcl_WaitForEvent)(timePtr) /* 13 */
         1501  +#define Tcl_WaitForEvent \
         1502  +	(tclStubsPtr->tcl_WaitForEvent) /* 13 */
  1503   1503   #endif
  1504   1504   #ifndef Tcl_AppendAllObjTypes
  1505         -#define Tcl_AppendAllObjTypes(interp, objPtr) \
  1506         -	(tclStubsPtr->tcl_AppendAllObjTypes)(interp, objPtr) /* 14 */
         1505  +#define Tcl_AppendAllObjTypes \
         1506  +	(tclStubsPtr->tcl_AppendAllObjTypes) /* 14 */
  1507   1507   #endif
  1508   1508   #ifndef Tcl_AppendStringsToObj
  1509   1509   #define Tcl_AppendStringsToObj \
  1510   1510   	(tclStubsPtr->tcl_AppendStringsToObj) /* 15 */
  1511   1511   #endif
  1512   1512   #ifndef Tcl_AppendToObj
  1513         -#define Tcl_AppendToObj(objPtr, bytes, length) \
  1514         -	(tclStubsPtr->tcl_AppendToObj)(objPtr, bytes, length) /* 16 */
         1513  +#define Tcl_AppendToObj \
         1514  +	(tclStubsPtr->tcl_AppendToObj) /* 16 */
  1515   1515   #endif
  1516   1516   #ifndef Tcl_ConcatObj
  1517         -#define Tcl_ConcatObj(objc, objv) \
  1518         -	(tclStubsPtr->tcl_ConcatObj)(objc, objv) /* 17 */
         1517  +#define Tcl_ConcatObj \
         1518  +	(tclStubsPtr->tcl_ConcatObj) /* 17 */
  1519   1519   #endif
  1520   1520   #ifndef Tcl_ConvertToType
  1521         -#define Tcl_ConvertToType(interp, objPtr, typePtr) \
  1522         -	(tclStubsPtr->tcl_ConvertToType)(interp, objPtr, typePtr) /* 18 */
         1521  +#define Tcl_ConvertToType \
         1522  +	(tclStubsPtr->tcl_ConvertToType) /* 18 */
  1523   1523   #endif
  1524   1524   #ifndef Tcl_DbDecrRefCount
  1525         -#define Tcl_DbDecrRefCount(objPtr, file, line) \
  1526         -	(tclStubsPtr->tcl_DbDecrRefCount)(objPtr, file, line) /* 19 */
         1525  +#define Tcl_DbDecrRefCount \
         1526  +	(tclStubsPtr->tcl_DbDecrRefCount) /* 19 */
  1527   1527   #endif
  1528   1528   #ifndef Tcl_DbIncrRefCount
  1529         -#define Tcl_DbIncrRefCount(objPtr, file, line) \
  1530         -	(tclStubsPtr->tcl_DbIncrRefCount)(objPtr, file, line) /* 20 */
         1529  +#define Tcl_DbIncrRefCount \
         1530  +	(tclStubsPtr->tcl_DbIncrRefCount) /* 20 */
  1531   1531   #endif
  1532   1532   #ifndef Tcl_DbIsShared
  1533         -#define Tcl_DbIsShared(objPtr, file, line) \
  1534         -	(tclStubsPtr->tcl_DbIsShared)(objPtr, file, line) /* 21 */
         1533  +#define Tcl_DbIsShared \
         1534  +	(tclStubsPtr->tcl_DbIsShared) /* 21 */
  1535   1535   #endif
  1536   1536   #ifndef Tcl_DbNewBooleanObj
  1537         -#define Tcl_DbNewBooleanObj(boolValue, file, line) \
  1538         -	(tclStubsPtr->tcl_DbNewBooleanObj)(boolValue, file, line) /* 22 */
         1537  +#define Tcl_DbNewBooleanObj \
         1538  +	(tclStubsPtr->tcl_DbNewBooleanObj) /* 22 */
  1539   1539   #endif
  1540   1540   #ifndef Tcl_DbNewByteArrayObj
  1541         -#define Tcl_DbNewByteArrayObj(bytes, length, file, line) \
  1542         -	(tclStubsPtr->tcl_DbNewByteArrayObj)(bytes, length, file, line) /* 23 */
         1541  +#define Tcl_DbNewByteArrayObj \
         1542  +	(tclStubsPtr->tcl_DbNewByteArrayObj) /* 23 */
  1543   1543   #endif
  1544   1544   #ifndef Tcl_DbNewDoubleObj
  1545         -#define Tcl_DbNewDoubleObj(doubleValue, file, line) \
  1546         -	(tclStubsPtr->tcl_DbNewDoubleObj)(doubleValue, file, line) /* 24 */
         1545  +#define Tcl_DbNewDoubleObj \
         1546  +	(tclStubsPtr->tcl_DbNewDoubleObj) /* 24 */
  1547   1547   #endif
  1548   1548   #ifndef Tcl_DbNewListObj
  1549         -#define Tcl_DbNewListObj(objc, objv, file, line) \
  1550         -	(tclStubsPtr->tcl_DbNewListObj)(objc, objv, file, line) /* 25 */
         1549  +#define Tcl_DbNewListObj \
         1550  +	(tclStubsPtr->tcl_DbNewListObj) /* 25 */
  1551   1551   #endif
  1552   1552   #ifndef Tcl_DbNewLongObj
  1553         -#define Tcl_DbNewLongObj(longValue, file, line) \
  1554         -	(tclStubsPtr->tcl_DbNewLongObj)(longValue, file, line) /* 26 */
         1553  +#define Tcl_DbNewLongObj \
         1554  +	(tclStubsPtr->tcl_DbNewLongObj) /* 26 */
  1555   1555   #endif
  1556   1556   #ifndef Tcl_DbNewObj
  1557         -#define Tcl_DbNewObj(file, line) \
  1558         -	(tclStubsPtr->tcl_DbNewObj)(file, line) /* 27 */
         1557  +#define Tcl_DbNewObj \
         1558  +	(tclStubsPtr->tcl_DbNewObj) /* 27 */
  1559   1559   #endif
  1560   1560   #ifndef Tcl_DbNewStringObj
  1561         -#define Tcl_DbNewStringObj(bytes, length, file, line) \
  1562         -	(tclStubsPtr->tcl_DbNewStringObj)(bytes, length, file, line) /* 28 */
         1561  +#define Tcl_DbNewStringObj \
         1562  +	(tclStubsPtr->tcl_DbNewStringObj) /* 28 */
  1563   1563   #endif
  1564   1564   #ifndef Tcl_DuplicateObj
  1565         -#define Tcl_DuplicateObj(objPtr) \
  1566         -	(tclStubsPtr->tcl_DuplicateObj)(objPtr) /* 29 */
         1565  +#define Tcl_DuplicateObj \
         1566  +	(tclStubsPtr->tcl_DuplicateObj) /* 29 */
  1567   1567   #endif
  1568   1568   #ifndef TclFreeObj
  1569         -#define TclFreeObj(objPtr) \
  1570         -	(tclStubsPtr->tclFreeObj)(objPtr) /* 30 */
         1569  +#define TclFreeObj \
         1570  +	(tclStubsPtr->tclFreeObj) /* 30 */
  1571   1571   #endif
  1572   1572   #ifndef Tcl_GetBoolean
  1573         -#define Tcl_GetBoolean(interp, str, boolPtr) \
  1574         -	(tclStubsPtr->tcl_GetBoolean)(interp, str, boolPtr) /* 31 */
         1573  +#define Tcl_GetBoolean \
         1574  +	(tclStubsPtr->tcl_GetBoolean) /* 31 */
  1575   1575   #endif
  1576   1576   #ifndef Tcl_GetBooleanFromObj
  1577         -#define Tcl_GetBooleanFromObj(interp, objPtr, boolPtr) \
  1578         -	(tclStubsPtr->tcl_GetBooleanFromObj)(interp, objPtr, boolPtr) /* 32 */
         1577  +#define Tcl_GetBooleanFromObj \
         1578  +	(tclStubsPtr->tcl_GetBooleanFromObj) /* 32 */
  1579   1579   #endif
  1580   1580   #ifndef Tcl_GetByteArrayFromObj
  1581         -#define Tcl_GetByteArrayFromObj(objPtr, lengthPtr) \
  1582         -	(tclStubsPtr->tcl_GetByteArrayFromObj)(objPtr, lengthPtr) /* 33 */
         1581  +#define Tcl_GetByteArrayFromObj \
         1582  +	(tclStubsPtr->tcl_GetByteArrayFromObj) /* 33 */
  1583   1583   #endif
  1584   1584   #ifndef Tcl_GetDouble
  1585         -#define Tcl_GetDouble(interp, str, doublePtr) \
  1586         -	(tclStubsPtr->tcl_GetDouble)(interp, str, doublePtr) /* 34 */
         1585  +#define Tcl_GetDouble \
         1586  +	(tclStubsPtr->tcl_GetDouble) /* 34 */
  1587   1587   #endif
  1588   1588   #ifndef Tcl_GetDoubleFromObj
  1589         -#define Tcl_GetDoubleFromObj(interp, objPtr, doublePtr) \
  1590         -	(tclStubsPtr->tcl_GetDoubleFromObj)(interp, objPtr, doublePtr) /* 35 */
         1589  +#define Tcl_GetDoubleFromObj \
         1590  +	(tclStubsPtr->tcl_GetDoubleFromObj) /* 35 */
  1591   1591   #endif
  1592   1592   #ifndef Tcl_GetIndexFromObj
  1593         -#define Tcl_GetIndexFromObj(interp, objPtr, tablePtr, msg, flags, indexPtr) \
  1594         -	(tclStubsPtr->tcl_GetIndexFromObj)(interp, objPtr, tablePtr, msg, flags, indexPtr) /* 36 */
         1593  +#define Tcl_GetIndexFromObj \
         1594  +	(tclStubsPtr->tcl_GetIndexFromObj) /* 36 */
  1595   1595   #endif
  1596   1596   #ifndef Tcl_GetInt
  1597         -#define Tcl_GetInt(interp, str, intPtr) \
  1598         -	(tclStubsPtr->tcl_GetInt)(interp, str, intPtr) /* 37 */
         1597  +#define Tcl_GetInt \
         1598  +	(tclStubsPtr->tcl_GetInt) /* 37 */
  1599   1599   #endif
  1600   1600   #ifndef Tcl_GetIntFromObj
  1601         -#define Tcl_GetIntFromObj(interp, objPtr, intPtr) \
  1602         -	(tclStubsPtr->tcl_GetIntFromObj)(interp, objPtr, intPtr) /* 38 */
         1601  +#define Tcl_GetIntFromObj \
         1602  +	(tclStubsPtr->tcl_GetIntFromObj) /* 38 */
  1603   1603   #endif
  1604   1604   #ifndef Tcl_GetLongFromObj
  1605         -#define Tcl_GetLongFromObj(interp, objPtr, longPtr) \
  1606         -	(tclStubsPtr->tcl_GetLongFromObj)(interp, objPtr, longPtr) /* 39 */
         1605  +#define Tcl_GetLongFromObj \
         1606  +	(tclStubsPtr->tcl_GetLongFromObj) /* 39 */
  1607   1607   #endif
  1608   1608   #ifndef Tcl_GetObjType
  1609         -#define Tcl_GetObjType(typeName) \
  1610         -	(tclStubsPtr->tcl_GetObjType)(typeName) /* 40 */
         1609  +#define Tcl_GetObjType \
         1610  +	(tclStubsPtr->tcl_GetObjType) /* 40 */
  1611   1611   #endif
  1612   1612   #ifndef Tcl_GetStringFromObj
  1613         -#define Tcl_GetStringFromObj(objPtr, lengthPtr) \
  1614         -	(tclStubsPtr->tcl_GetStringFromObj)(objPtr, lengthPtr) /* 41 */
         1613  +#define Tcl_GetStringFromObj \
         1614  +	(tclStubsPtr->tcl_GetStringFromObj) /* 41 */
  1615   1615   #endif
  1616   1616   #ifndef Tcl_InvalidateStringRep
  1617         -#define Tcl_InvalidateStringRep(objPtr) \
  1618         -	(tclStubsPtr->tcl_InvalidateStringRep)(objPtr) /* 42 */
         1617  +#define Tcl_InvalidateStringRep \
         1618  +	(tclStubsPtr->tcl_InvalidateStringRep) /* 42 */
  1619   1619   #endif
  1620   1620   #ifndef Tcl_ListObjAppendList
  1621         -#define Tcl_ListObjAppendList(interp, listPtr, elemListPtr) \
  1622         -	(tclStubsPtr->tcl_ListObjAppendList)(interp, listPtr, elemListPtr) /* 43 */
         1621  +#define Tcl_ListObjAppendList \
         1622  +	(tclStubsPtr->tcl_ListObjAppendList) /* 43 */
  1623   1623   #endif
  1624   1624   #ifndef Tcl_ListObjAppendElement
  1625         -#define Tcl_ListObjAppendElement(interp, listPtr, objPtr) \
  1626         -	(tclStubsPtr->tcl_ListObjAppendElement)(interp, listPtr, objPtr) /* 44 */
         1625  +#define Tcl_ListObjAppendElement \
         1626  +	(tclStubsPtr->tcl_ListObjAppendElement) /* 44 */
  1627   1627   #endif
  1628   1628   #ifndef Tcl_ListObjGetElements
  1629         -#define Tcl_ListObjGetElements(interp, listPtr, objcPtr, objvPtr) \
  1630         -	(tclStubsPtr->tcl_ListObjGetElements)(interp, listPtr, objcPtr, objvPtr) /* 45 */
         1629  +#define Tcl_ListObjGetElements \
         1630  +	(tclStubsPtr->tcl_ListObjGetElements) /* 45 */
  1631   1631   #endif
  1632   1632   #ifndef Tcl_ListObjIndex
  1633         -#define Tcl_ListObjIndex(interp, listPtr, index, objPtrPtr) \
  1634         -	(tclStubsPtr->tcl_ListObjIndex)(interp, listPtr, index, objPtrPtr) /* 46 */
         1633  +#define Tcl_ListObjIndex \
         1634  +	(tclStubsPtr->tcl_ListObjIndex) /* 46 */
  1635   1635   #endif
  1636   1636   #ifndef Tcl_ListObjLength
  1637         -#define Tcl_ListObjLength(interp, listPtr, intPtr) \
  1638         -	(tclStubsPtr->tcl_ListObjLength)(interp, listPtr, intPtr) /* 47 */
         1637  +#define Tcl_ListObjLength \
         1638  +	(tclStubsPtr->tcl_ListObjLength) /* 47 */
  1639   1639   #endif
  1640   1640   #ifndef Tcl_ListObjReplace
  1641         -#define Tcl_ListObjReplace(interp, listPtr, first, count, objc, objv) \
  1642         -	(tclStubsPtr->tcl_ListObjReplace)(interp, listPtr, first, count, objc, objv) /* 48 */
         1641  +#define Tcl_ListObjReplace \
         1642  +	(tclStubsPtr->tcl_ListObjReplace) /* 48 */
  1643   1643   #endif
  1644   1644   #ifndef Tcl_NewBooleanObj
  1645         -#define Tcl_NewBooleanObj(boolValue) \
  1646         -	(tclStubsPtr->tcl_NewBooleanObj)(boolValue) /* 49 */
         1645  +#define Tcl_NewBooleanObj \
         1646  +	(tclStubsPtr->tcl_NewBooleanObj) /* 49 */
  1647   1647   #endif
  1648   1648   #ifndef Tcl_NewByteArrayObj
  1649         -#define Tcl_NewByteArrayObj(bytes, length) \
  1650         -	(tclStubsPtr->tcl_NewByteArrayObj)(bytes, length) /* 50 */
         1649  +#define Tcl_NewByteArrayObj \
         1650  +	(tclStubsPtr->tcl_NewByteArrayObj) /* 50 */
  1651   1651   #endif
  1652   1652   #ifndef Tcl_NewDoubleObj
  1653         -#define Tcl_NewDoubleObj(doubleValue) \
  1654         -	(tclStubsPtr->tcl_NewDoubleObj)(doubleValue) /* 51 */
         1653  +#define Tcl_NewDoubleObj \
         1654  +	(tclStubsPtr->tcl_NewDoubleObj) /* 51 */
  1655   1655   #endif
  1656   1656   #ifndef Tcl_NewIntObj
  1657         -#define Tcl_NewIntObj(intValue) \
  1658         -	(tclStubsPtr->tcl_NewIntObj)(intValue) /* 52 */
         1657  +#define Tcl_NewIntObj \
         1658  +	(tclStubsPtr->tcl_NewIntObj) /* 52 */
  1659   1659   #endif
  1660   1660   #ifndef Tcl_NewListObj
  1661         -#define Tcl_NewListObj(objc, objv) \
  1662         -	(tclStubsPtr->tcl_NewListObj)(objc, objv) /* 53 */
         1661  +#define Tcl_NewListObj \
         1662  +	(tclStubsPtr->tcl_NewListObj) /* 53 */
  1663   1663   #endif
  1664   1664   #ifndef Tcl_NewLongObj
  1665         -#define Tcl_NewLongObj(longValue) \
  1666         -	(tclStubsPtr->tcl_NewLongObj)(longValue) /* 54 */
         1665  +#define Tcl_NewLongObj \
         1666  +	(tclStubsPtr->tcl_NewLongObj) /* 54 */
  1667   1667   #endif
  1668   1668   #ifndef Tcl_NewObj
  1669         -#define Tcl_NewObj() \
  1670         -	(tclStubsPtr->tcl_NewObj)() /* 55 */
         1669  +#define Tcl_NewObj \
         1670  +	(tclStubsPtr->tcl_NewObj) /* 55 */
  1671   1671   #endif
  1672   1672   #ifndef Tcl_NewStringObj
  1673         -#define Tcl_NewStringObj(bytes, length) \
  1674         -	(tclStubsPtr->tcl_NewStringObj)(bytes, length) /* 56 */
         1673  +#define Tcl_NewStringObj \
         1674  +	(tclStubsPtr->tcl_NewStringObj) /* 56 */
  1675   1675   #endif
  1676   1676   #ifndef Tcl_SetBooleanObj
  1677         -#define Tcl_SetBooleanObj(objPtr, boolValue) \
  1678         -	(tclStubsPtr->tcl_SetBooleanObj)(objPtr, boolValue) /* 57 */
         1677  +#define Tcl_SetBooleanObj \
         1678  +	(tclStubsPtr->tcl_SetBooleanObj) /* 57 */
  1679   1679   #endif
  1680   1680   #ifndef Tcl_SetByteArrayLength
  1681         -#define Tcl_SetByteArrayLength(objPtr, length) \
  1682         -	(tclStubsPtr->tcl_SetByteArrayLength)(objPtr, length) /* 58 */
         1681  +#define Tcl_SetByteArrayLength \
         1682  +	(tclStubsPtr->tcl_SetByteArrayLength) /* 58 */
  1683   1683   #endif
  1684   1684   #ifndef Tcl_SetByteArrayObj
  1685         -#define Tcl_SetByteArrayObj(objPtr, bytes, length) \
  1686         -	(tclStubsPtr->tcl_SetByteArrayObj)(objPtr, bytes, length) /* 59 */
         1685  +#define Tcl_SetByteArrayObj \
         1686  +	(tclStubsPtr->tcl_SetByteArrayObj) /* 59 */
  1687   1687   #endif
  1688   1688   #ifndef Tcl_SetDoubleObj
  1689         -#define Tcl_SetDoubleObj(objPtr, doubleValue) \
  1690         -	(tclStubsPtr->tcl_SetDoubleObj)(objPtr, doubleValue) /* 60 */
         1689  +#define Tcl_SetDoubleObj \
         1690  +	(tclStubsPtr->tcl_SetDoubleObj) /* 60 */
  1691   1691   #endif
  1692   1692   #ifndef Tcl_SetIntObj
  1693         -#define Tcl_SetIntObj(objPtr, intValue) \
  1694         -	(tclStubsPtr->tcl_SetIntObj)(objPtr, intValue) /* 61 */
         1693  +#define Tcl_SetIntObj \
         1694  +	(tclStubsPtr->tcl_SetIntObj) /* 61 */
  1695   1695   #endif
  1696   1696   #ifndef Tcl_SetListObj
  1697         -#define Tcl_SetListObj(objPtr, objc, objv) \
  1698         -	(tclStubsPtr->tcl_SetListObj)(objPtr, objc, objv) /* 62 */
         1697  +#define Tcl_SetListObj \
         1698  +	(tclStubsPtr->tcl_SetListObj) /* 62 */
  1699   1699   #endif
  1700   1700   #ifndef Tcl_SetLongObj
  1701         -#define Tcl_SetLongObj(objPtr, longValue) \
  1702         -	(tclStubsPtr->tcl_SetLongObj)(objPtr, longValue) /* 63 */
         1701  +#define Tcl_SetLongObj \
         1702  +	(tclStubsPtr->tcl_SetLongObj) /* 63 */
  1703   1703   #endif
  1704   1704   #ifndef Tcl_SetObjLength
  1705         -#define Tcl_SetObjLength(objPtr, length) \
  1706         -	(tclStubsPtr->tcl_SetObjLength)(objPtr, length) /* 64 */
         1705  +#define Tcl_SetObjLength \
         1706  +	(tclStubsPtr->tcl_SetObjLength) /* 64 */
  1707   1707   #endif
  1708   1708   #ifndef Tcl_SetStringObj
  1709         -#define Tcl_SetStringObj(objPtr, bytes, length) \
  1710         -	(tclStubsPtr->tcl_SetStringObj)(objPtr, bytes, length) /* 65 */
         1709  +#define Tcl_SetStringObj \
         1710  +	(tclStubsPtr->tcl_SetStringObj) /* 65 */
  1711   1711   #endif
  1712   1712   #ifndef Tcl_AddErrorInfo
  1713         -#define Tcl_AddErrorInfo(interp, message) \
  1714         -	(tclStubsPtr->tcl_AddErrorInfo)(interp, message) /* 66 */
         1713  +#define Tcl_AddErrorInfo \
         1714  +	(tclStubsPtr->tcl_AddErrorInfo) /* 66 */
  1715   1715   #endif
  1716   1716   #ifndef Tcl_AddObjErrorInfo
  1717         -#define Tcl_AddObjErrorInfo(interp, message, length) \
  1718         -	(tclStubsPtr->tcl_AddObjErrorInfo)(interp, message, length) /* 67 */
         1717  +#define Tcl_AddObjErrorInfo \
         1718  +	(tclStubsPtr->tcl_AddObjErrorInfo) /* 67 */
  1719   1719   #endif
  1720   1720   #ifndef Tcl_AllowExceptions
  1721         -#define Tcl_AllowExceptions(interp) \
  1722         -	(tclStubsPtr->tcl_AllowExceptions)(interp) /* 68 */
         1721  +#define Tcl_AllowExceptions \
         1722  +	(tclStubsPtr->tcl_AllowExceptions) /* 68 */
  1723   1723   #endif
  1724   1724   #ifndef Tcl_AppendElement
  1725         -#define Tcl_AppendElement(interp, string) \
  1726         -	(tclStubsPtr->tcl_AppendElement)(interp, string) /* 69 */
         1725  +#define Tcl_AppendElement \
         1726  +	(tclStubsPtr->tcl_AppendElement) /* 69 */
  1727   1727   #endif
  1728   1728   #ifndef Tcl_AppendResult
  1729   1729   #define Tcl_AppendResult \
  1730   1730   	(tclStubsPtr->tcl_AppendResult) /* 70 */
  1731   1731   #endif
  1732   1732   #ifndef Tcl_AsyncCreate
  1733         -#define Tcl_AsyncCreate(proc, clientData) \
  1734         -	(tclStubsPtr->tcl_AsyncCreate)(proc, clientData) /* 71 */
         1733  +#define Tcl_AsyncCreate \
         1734  +	(tclStubsPtr->tcl_AsyncCreate) /* 71 */
  1735   1735   #endif
  1736   1736   #ifndef Tcl_AsyncDelete
  1737         -#define Tcl_AsyncDelete(async) \
  1738         -	(tclStubsPtr->tcl_AsyncDelete)(async) /* 72 */
         1737  +#define Tcl_AsyncDelete \
         1738  +	(tclStubsPtr->tcl_AsyncDelete) /* 72 */
  1739   1739   #endif
  1740   1740   #ifndef Tcl_AsyncInvoke
  1741         -#define Tcl_AsyncInvoke(interp, code) \
  1742         -	(tclStubsPtr->tcl_AsyncInvoke)(interp, code) /* 73 */
         1741  +#define Tcl_AsyncInvoke \
         1742  +	(tclStubsPtr->tcl_AsyncInvoke) /* 73 */
  1743   1743   #endif
  1744   1744   #ifndef Tcl_AsyncMark
  1745         -#define Tcl_AsyncMark(async) \
  1746         -	(tclStubsPtr->tcl_AsyncMark)(async) /* 74 */
         1745  +#define Tcl_AsyncMark \
         1746  +	(tclStubsPtr->tcl_AsyncMark) /* 74 */
  1747   1747   #endif
  1748   1748   #ifndef Tcl_AsyncReady
  1749         -#define Tcl_AsyncReady() \
  1750         -	(tclStubsPtr->tcl_AsyncReady)() /* 75 */
         1749  +#define Tcl_AsyncReady \
         1750  +	(tclStubsPtr->tcl_AsyncReady) /* 75 */
  1751   1751   #endif
  1752   1752   #ifndef Tcl_BackgroundError
  1753         -#define Tcl_BackgroundError(interp) \
  1754         -	(tclStubsPtr->tcl_BackgroundError)(interp) /* 76 */
         1753  +#define Tcl_BackgroundError \
         1754  +	(tclStubsPtr->tcl_BackgroundError) /* 76 */
  1755   1755   #endif
  1756   1756   #ifndef Tcl_Backslash
  1757         -#define Tcl_Backslash(src, readPtr) \
  1758         -	(tclStubsPtr->tcl_Backslash)(src, readPtr) /* 77 */
         1757  +#define Tcl_Backslash \
         1758  +	(tclStubsPtr->tcl_Backslash) /* 77 */
  1759   1759   #endif
  1760   1760   #ifndef Tcl_BadChannelOption
  1761         -#define Tcl_BadChannelOption(interp, optionName, optionList) \
  1762         -	(tclStubsPtr->tcl_BadChannelOption)(interp, optionName, optionList) /* 78 */
         1761  +#define Tcl_BadChannelOption \
         1762  +	(tclStubsPtr->tcl_BadChannelOption) /* 78 */
  1763   1763   #endif
  1764   1764   #ifndef Tcl_CallWhenDeleted
  1765         -#define Tcl_CallWhenDeleted(interp, proc, clientData) \
  1766         -	(tclStubsPtr->tcl_CallWhenDeleted)(interp, proc, clientData) /* 79 */
         1765  +#define Tcl_CallWhenDeleted \
         1766  +	(tclStubsPtr->tcl_CallWhenDeleted) /* 79 */
  1767   1767   #endif
  1768   1768   #ifndef Tcl_CancelIdleCall
  1769         -#define Tcl_CancelIdleCall(idleProc, clientData) \
  1770         -	(tclStubsPtr->tcl_CancelIdleCall)(idleProc, clientData) /* 80 */
         1769  +#define Tcl_CancelIdleCall \
         1770  +	(tclStubsPtr->tcl_CancelIdleCall) /* 80 */
  1771   1771   #endif
  1772   1772   #ifndef Tcl_Close
  1773         -#define Tcl_Close(interp, chan) \
  1774         -	(tclStubsPtr->tcl_Close)(interp, chan) /* 81 */
         1773  +#define Tcl_Close \
         1774  +	(tclStubsPtr->tcl_Close) /* 81 */
  1775   1775   #endif
  1776   1776   #ifndef Tcl_CommandComplete
  1777         -#define Tcl_CommandComplete(cmd) \
  1778         -	(tclStubsPtr->tcl_CommandComplete)(cmd) /* 82 */
         1777  +#define Tcl_CommandComplete \
         1778  +	(tclStubsPtr->tcl_CommandComplete) /* 82 */
  1779   1779   #endif
  1780   1780   #ifndef Tcl_Concat
  1781         -#define Tcl_Concat(argc, argv) \
  1782         -	(tclStubsPtr->tcl_Concat)(argc, argv) /* 83 */
         1781  +#define Tcl_Concat \
         1782  +	(tclStubsPtr->tcl_Concat) /* 83 */
  1783   1783   #endif
  1784   1784   #ifndef Tcl_ConvertElement
  1785         -#define Tcl_ConvertElement(src, dst, flags) \
  1786         -	(tclStubsPtr->tcl_ConvertElement)(src, dst, flags) /* 84 */
         1785  +#define Tcl_ConvertElement \
         1786  +	(tclStubsPtr->tcl_ConvertElement) /* 84 */
  1787   1787   #endif
  1788   1788   #ifndef Tcl_ConvertCountedElement
  1789         -#define Tcl_ConvertCountedElement(src, length, dst, flags) \
  1790         -	(tclStubsPtr->tcl_ConvertCountedElement)(src, length, dst, flags) /* 85 */
         1789  +#define Tcl_ConvertCountedElement \
         1790  +	(tclStubsPtr->tcl_ConvertCountedElement) /* 85 */
  1791   1791   #endif
  1792   1792   #ifndef Tcl_CreateAlias
  1793         -#define Tcl_CreateAlias(slave, slaveCmd, target, targetCmd, argc, argv) \
  1794         -	(tclStubsPtr->tcl_CreateAlias)(slave, slaveCmd, target, targetCmd, argc, argv) /* 86 */
         1793  +#define Tcl_CreateAlias \
         1794  +	(tclStubsPtr->tcl_CreateAlias) /* 86 */
  1795   1795   #endif
  1796   1796   #ifndef Tcl_CreateAliasObj
  1797         -#define Tcl_CreateAliasObj(slave, slaveCmd, target, targetCmd, objc, objv) \
  1798         -	(tclStubsPtr->tcl_CreateAliasObj)(slave, slaveCmd, target, targetCmd, objc, objv) /* 87 */
         1797  +#define Tcl_CreateAliasObj \
         1798  +	(tclStubsPtr->tcl_CreateAliasObj) /* 87 */
  1799   1799   #endif
  1800   1800   #ifndef Tcl_CreateChannel
  1801         -#define Tcl_CreateChannel(typePtr, chanName, instanceData, mask) \
  1802         -	(tclStubsPtr->tcl_CreateChannel)(typePtr, chanName, instanceData, mask) /* 88 */
         1801  +#define Tcl_CreateChannel \
         1802  +	(tclStubsPtr->tcl_CreateChannel) /* 88 */
  1803   1803   #endif
  1804   1804   #ifndef Tcl_CreateChannelHandler
  1805         -#define Tcl_CreateChannelHandler(chan, mask, proc, clientData) \
  1806         -	(tclStubsPtr->tcl_CreateChannelHandler)(chan, mask, proc, clientData) /* 89 */
         1805  +#define Tcl_CreateChannelHandler \
         1806  +	(tclStubsPtr->tcl_CreateChannelHandler) /* 89 */
  1807   1807   #endif
  1808   1808   #ifndef Tcl_CreateCloseHandler
  1809         -#define Tcl_CreateCloseHandler(chan, proc, clientData) \
  1810         -	(tclStubsPtr->tcl_CreateCloseHandler)(chan, proc, clientData) /* 90 */
         1809  +#define Tcl_CreateCloseHandler \
         1810  +	(tclStubsPtr->tcl_CreateCloseHandler) /* 90 */
  1811   1811   #endif
  1812   1812   #ifndef Tcl_CreateCommand
  1813         -#define Tcl_CreateCommand(interp, cmdName, proc, clientData, deleteProc) \
  1814         -	(tclStubsPtr->tcl_CreateCommand)(interp, cmdName, proc, clientData, deleteProc) /* 91 */
         1813  +#define Tcl_CreateCommand \
         1814  +	(tclStubsPtr->tcl_CreateCommand) /* 91 */
  1815   1815   #endif
  1816   1816   #ifndef Tcl_CreateEventSource
  1817         -#define Tcl_CreateEventSource(setupProc, checkProc, clientData) \
  1818         -	(tclStubsPtr->tcl_CreateEventSource)(setupProc, checkProc, clientData) /* 92 */
         1817  +#define Tcl_CreateEventSource \
         1818  +	(tclStubsPtr->tcl_CreateEventSource) /* 92 */
  1819   1819   #endif
  1820   1820   #ifndef Tcl_CreateExitHandler
  1821         -#define Tcl_CreateExitHandler(proc, clientData) \
  1822         -	(tclStubsPtr->tcl_CreateExitHandler)(proc, clientData) /* 93 */
         1821  +#define Tcl_CreateExitHandler \
         1822  +	(tclStubsPtr->tcl_CreateExitHandler) /* 93 */
  1823   1823   #endif
  1824   1824   #ifndef Tcl_CreateInterp
  1825         -#define Tcl_CreateInterp() \
  1826         -	(tclStubsPtr->tcl_CreateInterp)() /* 94 */
         1825  +#define Tcl_CreateInterp \
         1826  +	(tclStubsPtr->tcl_CreateInterp) /* 94 */
  1827   1827   #endif
  1828   1828   #ifndef Tcl_CreateMathFunc
  1829         -#define Tcl_CreateMathFunc(interp, name, numArgs, argTypes, proc, clientData) \
  1830         -	(tclStubsPtr->tcl_CreateMathFunc)(interp, name, numArgs, argTypes, proc, clientData) /* 95 */
         1829  +#define Tcl_CreateMathFunc \
         1830  +	(tclStubsPtr->tcl_CreateMathFunc) /* 95 */
  1831   1831   #endif
  1832   1832   #ifndef Tcl_CreateObjCommand
  1833         -#define Tcl_CreateObjCommand(interp, cmdName, proc, clientData, deleteProc) \
  1834         -	(tclStubsPtr->tcl_CreateObjCommand)(interp, cmdName, proc, clientData, deleteProc) /* 96 */
         1833  +#define Tcl_CreateObjCommand \
         1834  +	(tclStubsPtr->tcl_CreateObjCommand) /* 96 */
  1835   1835   #endif
  1836   1836   #ifndef Tcl_CreateSlave
  1837         -#define Tcl_CreateSlave(interp, slaveName, isSafe) \
  1838         -	(tclStubsPtr->tcl_CreateSlave)(interp, slaveName, isSafe) /* 97 */
         1837  +#define Tcl_CreateSlave \
         1838  +	(tclStubsPtr->tcl_CreateSlave) /* 97 */
  1839   1839   #endif
  1840   1840   #ifndef Tcl_CreateTimerHandler
  1841         -#define Tcl_CreateTimerHandler(milliseconds, proc, clientData) \
  1842         -	(tclStubsPtr->tcl_CreateTimerHandler)(milliseconds, proc, clientData) /* 98 */
         1841  +#define Tcl_CreateTimerHandler \
         1842  +	(tclStubsPtr->tcl_CreateTimerHandler) /* 98 */
  1843   1843   #endif
  1844   1844   #ifndef Tcl_CreateTrace
  1845         -#define Tcl_CreateTrace(interp, level, proc, clientData) \
  1846         -	(tclStubsPtr->tcl_CreateTrace)(interp, level, proc, clientData) /* 99 */
         1845  +#define Tcl_CreateTrace \
         1846  +	(tclStubsPtr->tcl_CreateTrace) /* 99 */
  1847   1847   #endif
  1848   1848   #ifndef Tcl_DeleteAssocData
  1849         -#define Tcl_DeleteAssocData(interp, name) \
  1850         -	(tclStubsPtr->tcl_DeleteAssocData)(interp, name) /* 100 */
         1849  +#define Tcl_DeleteAssocData \
         1850  +	(tclStubsPtr->tcl_DeleteAssocData) /* 100 */
  1851   1851   #endif
  1852   1852   #ifndef Tcl_DeleteChannelHandler
  1853         -#define Tcl_DeleteChannelHandler(chan, proc, clientData) \
  1854         -	(tclStubsPtr->tcl_DeleteChannelHandler)(chan, proc, clientData) /* 101 */
         1853  +#define Tcl_DeleteChannelHandler \
         1854  +	(tclStubsPtr->tcl_DeleteChannelHandler) /* 101 */
  1855   1855   #endif
  1856   1856   #ifndef Tcl_DeleteCloseHandler
  1857         -#define Tcl_DeleteCloseHandler(chan, proc, clientData) \
  1858         -	(tclStubsPtr->tcl_DeleteCloseHandler)(chan, proc, clientData) /* 102 */
         1857  +#define Tcl_DeleteCloseHandler \
         1858  +	(tclStubsPtr->tcl_DeleteCloseHandler) /* 102 */
  1859   1859   #endif
  1860   1860   #ifndef Tcl_DeleteCommand
  1861         -#define Tcl_DeleteCommand(interp, cmdName) \
  1862         -	(tclStubsPtr->tcl_DeleteCommand)(interp, cmdName) /* 103 */
         1861  +#define Tcl_DeleteCommand \
         1862  +	(tclStubsPtr->tcl_DeleteCommand) /* 103 */
  1863   1863   #endif
  1864   1864   #ifndef Tcl_DeleteCommandFromToken
  1865         -#define Tcl_DeleteCommandFromToken(interp, command) \
  1866         -	(tclStubsPtr->tcl_DeleteCommandFromToken)(interp, command) /* 104 */
         1865  +#define Tcl_DeleteCommandFromToken \
         1866  +	(tclStubsPtr->tcl_DeleteCommandFromToken) /* 104 */
  1867   1867   #endif
  1868   1868   #ifndef Tcl_DeleteEvents
  1869         -#define Tcl_DeleteEvents(proc, clientData) \
  1870         -	(tclStubsPtr->tcl_DeleteEvents)(proc, clientData) /* 105 */
         1869  +#define Tcl_DeleteEvents \
         1870  +	(tclStubsPtr->tcl_DeleteEvents) /* 105 */
  1871   1871   #endif
  1872   1872   #ifndef Tcl_DeleteEventSource
  1873         -#define Tcl_DeleteEventSource(setupProc, checkProc, clientData) \
  1874         -	(tclStubsPtr->tcl_DeleteEventSource)(setupProc, checkProc, clientData) /* 106 */
         1873  +#define Tcl_DeleteEventSource \
         1874  +	(tclStubsPtr->tcl_DeleteEventSource) /* 106 */
  1875   1875   #endif
  1876   1876   #ifndef Tcl_DeleteExitHandler
  1877         -#define Tcl_DeleteExitHandler(proc, clientData) \
  1878         -	(tclStubsPtr->tcl_DeleteExitHandler)(proc, clientData) /* 107 */
         1877  +#define Tcl_DeleteExitHandler \
         1878  +	(tclStubsPtr->tcl_DeleteExitHandler) /* 107 */
  1879   1879   #endif
  1880   1880   #ifndef Tcl_DeleteHashEntry
  1881         -#define Tcl_DeleteHashEntry(entryPtr) \
  1882         -	(tclStubsPtr->tcl_DeleteHashEntry)(entryPtr) /* 108 */
         1881  +#define Tcl_DeleteHashEntry \
         1882  +	(tclStubsPtr->tcl_DeleteHashEntry) /* 108 */
  1883   1883   #endif
  1884   1884   #ifndef Tcl_DeleteHashTable
  1885         -#define Tcl_DeleteHashTable(tablePtr) \
  1886         -	(tclStubsPtr->tcl_DeleteHashTable)(tablePtr) /* 109 */
         1885  +#define Tcl_DeleteHashTable \
         1886  +	(tclStubsPtr->tcl_DeleteHashTable) /* 109 */
  1887   1887   #endif
  1888   1888   #ifndef Tcl_DeleteInterp
  1889         -#define Tcl_DeleteInterp(interp) \
  1890         -	(tclStubsPtr->tcl_DeleteInterp)(interp) /* 110 */
         1889  +#define Tcl_DeleteInterp \
         1890  +	(tclStubsPtr->tcl_DeleteInterp) /* 110 */
  1891   1891   #endif
  1892   1892   #ifndef Tcl_DetachPids
  1893         -#define Tcl_DetachPids(numPids, pidPtr) \
  1894         -	(tclStubsPtr->tcl_DetachPids)(numPids, pidPtr) /* 111 */
         1893  +#define Tcl_DetachPids \
         1894  +	(tclStubsPtr->tcl_DetachPids) /* 111 */
  1895   1895   #endif
  1896   1896   #ifndef Tcl_DeleteTimerHandler
  1897         -#define Tcl_DeleteTimerHandler(token) \
  1898         -	(tclStubsPtr->tcl_DeleteTimerHandler)(token) /* 112 */
         1897  +#define Tcl_DeleteTimerHandler \
         1898  +	(tclStubsPtr->tcl_DeleteTimerHandler) /* 112 */
  1899   1899   #endif
  1900   1900   #ifndef Tcl_DeleteTrace
  1901         -#define Tcl_DeleteTrace(interp, trace) \
  1902         -	(tclStubsPtr->tcl_DeleteTrace)(interp, trace) /* 113 */
         1901  +#define Tcl_DeleteTrace \
         1902  +	(tclStubsPtr->tcl_DeleteTrace) /* 113 */
  1903   1903   #endif
  1904   1904   #ifndef Tcl_DontCallWhenDeleted
  1905         -#define Tcl_DontCallWhenDeleted(interp, proc, clientData) \
  1906         -	(tclStubsPtr->tcl_DontCallWhenDeleted)(interp, proc, clientData) /* 114 */
         1905  +#define Tcl_DontCallWhenDeleted \
         1906  +	(tclStubsPtr->tcl_DontCallWhenDeleted) /* 114 */
  1907   1907   #endif
  1908   1908   #ifndef Tcl_DoOneEvent
  1909         -#define Tcl_DoOneEvent(flags) \
  1910         -	(tclStubsPtr->tcl_DoOneEvent)(flags) /* 115 */
         1909  +#define Tcl_DoOneEvent \
         1910  +	(tclStubsPtr->tcl_DoOneEvent) /* 115 */
  1911   1911   #endif
  1912   1912   #ifndef Tcl_DoWhenIdle
  1913         -#define Tcl_DoWhenIdle(proc, clientData) \
  1914         -	(tclStubsPtr->tcl_DoWhenIdle)(proc, clientData) /* 116 */
         1913  +#define Tcl_DoWhenIdle \
         1914  +	(tclStubsPtr->tcl_DoWhenIdle) /* 116 */
  1915   1915   #endif
  1916   1916   #ifndef Tcl_DStringAppend
  1917         -#define Tcl_DStringAppend(dsPtr, str, length) \
  1918         -	(tclStubsPtr->tcl_DStringAppend)(dsPtr, str, length) /* 117 */
         1917  +#define Tcl_DStringAppend \
         1918  +	(tclStubsPtr->tcl_DStringAppend) /* 117 */
  1919   1919   #endif
  1920   1920   #ifndef Tcl_DStringAppendElement
  1921         -#define Tcl_DStringAppendElement(dsPtr, string) \
  1922         -	(tclStubsPtr->tcl_DStringAppendElement)(dsPtr, string) /* 118 */
         1921  +#define Tcl_DStringAppendElement \
         1922  +	(tclStubsPtr->tcl_DStringAppendElement) /* 118 */
  1923   1923   #endif
  1924   1924   #ifndef Tcl_DStringEndSublist
  1925         -#define Tcl_DStringEndSublist(dsPtr) \
  1926         -	(tclStubsPtr->tcl_DStringEndSublist)(dsPtr) /* 119 */
         1925  +#define Tcl_DStringEndSublist \
         1926  +	(tclStubsPtr->tcl_DStringEndSublist) /* 119 */
  1927   1927   #endif
  1928   1928   #ifndef Tcl_DStringFree
  1929         -#define Tcl_DStringFree(dsPtr) \
  1930         -	(tclStubsPtr->tcl_DStringFree)(dsPtr) /* 120 */
         1929  +#define Tcl_DStringFree \
         1930  +	(tclStubsPtr->tcl_DStringFree) /* 120 */
  1931   1931   #endif
  1932   1932   #ifndef Tcl_DStringGetResult
  1933         -#define Tcl_DStringGetResult(interp, dsPtr) \
  1934         -	(tclStubsPtr->tcl_DStringGetResult)(interp, dsPtr) /* 121 */
         1933  +#define Tcl_DStringGetResult \
         1934  +	(tclStubsPtr->tcl_DStringGetResult) /* 121 */
  1935   1935   #endif
  1936   1936   #ifndef Tcl_DStringInit
  1937         -#define Tcl_DStringInit(dsPtr) \
  1938         -	(tclStubsPtr->tcl_DStringInit)(dsPtr) /* 122 */
         1937  +#define Tcl_DStringInit \
         1938  +	(tclStubsPtr->tcl_DStringInit) /* 122 */
  1939   1939   #endif
  1940   1940   #ifndef Tcl_DStringResult
  1941         -#define Tcl_DStringResult(interp, dsPtr) \
  1942         -	(tclStubsPtr->tcl_DStringResult)(interp, dsPtr) /* 123 */
         1941  +#define Tcl_DStringResult \
         1942  +	(tclStubsPtr->tcl_DStringResult) /* 123 */
  1943   1943   #endif
  1944   1944   #ifndef Tcl_DStringSetLength
  1945         -#define Tcl_DStringSetLength(dsPtr, length) \
  1946         -	(tclStubsPtr->tcl_DStringSetLength)(dsPtr, length) /* 124 */
         1945  +#define Tcl_DStringSetLength \
         1946  +	(tclStubsPtr->tcl_DStringSetLength) /* 124 */
  1947   1947   #endif
  1948   1948   #ifndef Tcl_DStringStartSublist
  1949         -#define Tcl_DStringStartSublist(dsPtr) \
  1950         -	(tclStubsPtr->tcl_DStringStartSublist)(dsPtr) /* 125 */
         1949  +#define Tcl_DStringStartSublist \
         1950  +	(tclStubsPtr->tcl_DStringStartSublist) /* 125 */
  1951   1951   #endif
  1952   1952   #ifndef Tcl_Eof
  1953         -#define Tcl_Eof(chan) \
  1954         -	(tclStubsPtr->tcl_Eof)(chan) /* 126 */
         1953  +#define Tcl_Eof \
         1954  +	(tclStubsPtr->tcl_Eof) /* 126 */
  1955   1955   #endif
  1956   1956   #ifndef Tcl_ErrnoId
  1957         -#define Tcl_ErrnoId() \
  1958         -	(tclStubsPtr->tcl_ErrnoId)() /* 127 */
         1957  +#define Tcl_ErrnoId \
         1958  +	(tclStubsPtr->tcl_ErrnoId) /* 127 */
  1959   1959   #endif
  1960   1960   #ifndef Tcl_ErrnoMsg
  1961         -#define Tcl_ErrnoMsg(err) \
  1962         -	(tclStubsPtr->tcl_ErrnoMsg)(err) /* 128 */
         1961  +#define Tcl_ErrnoMsg \
         1962  +	(tclStubsPtr->tcl_ErrnoMsg) /* 128 */
  1963   1963   #endif
  1964   1964   #ifndef Tcl_Eval
  1965         -#define Tcl_Eval(interp, string) \
  1966         -	(tclStubsPtr->tcl_Eval)(interp, string) /* 129 */
         1965  +#define Tcl_Eval \
         1966  +	(tclStubsPtr->tcl_Eval) /* 129 */
  1967   1967   #endif
  1968   1968   #ifndef Tcl_EvalFile
  1969         -#define Tcl_EvalFile(interp, fileName) \
  1970         -	(tclStubsPtr->tcl_EvalFile)(interp, fileName) /* 130 */
         1969  +#define Tcl_EvalFile \
         1970  +	(tclStubsPtr->tcl_EvalFile) /* 130 */
  1971   1971   #endif
  1972   1972   #ifndef Tcl_EvalObj
  1973         -#define Tcl_EvalObj(interp, objPtr) \
  1974         -	(tclStubsPtr->tcl_EvalObj)(interp, objPtr) /* 131 */
         1973  +#define Tcl_EvalObj \
         1974  +	(tclStubsPtr->tcl_EvalObj) /* 131 */
  1975   1975   #endif
  1976   1976   #ifndef Tcl_EventuallyFree
  1977         -#define Tcl_EventuallyFree(clientData, freeProc) \
  1978         -	(tclStubsPtr->tcl_EventuallyFree)(clientData, freeProc) /* 132 */
         1977  +#define Tcl_EventuallyFree \
         1978  +	(tclStubsPtr->tcl_EventuallyFree) /* 132 */
  1979   1979   #endif
  1980   1980   #ifndef Tcl_Exit
  1981         -#define Tcl_Exit(status) \
  1982         -	(tclStubsPtr->tcl_Exit)(status) /* 133 */
         1981  +#define Tcl_Exit \
         1982  +	(tclStubsPtr->tcl_Exit) /* 133 */
  1983   1983   #endif
  1984   1984   #ifndef Tcl_ExposeCommand
  1985         -#define Tcl_ExposeCommand(interp, hiddenCmdToken, cmdName) \
  1986         -	(tclStubsPtr->tcl_ExposeCommand)(interp, hiddenCmdToken, cmdName) /* 134 */
         1985  +#define Tcl_ExposeCommand \
         1986  +	(tclStubsPtr->tcl_ExposeCommand) /* 134 */
  1987   1987   #endif
  1988   1988   #ifndef Tcl_ExprBoolean
  1989         -#define Tcl_ExprBoolean(interp, str, ptr) \
  1990         -	(tclStubsPtr->tcl_ExprBoolean)(interp, str, ptr) /* 135 */
         1989  +#define Tcl_ExprBoolean \
         1990  +	(tclStubsPtr->tcl_ExprBoolean) /* 135 */
  1991   1991   #endif
  1992   1992   #ifndef Tcl_ExprBooleanObj
  1993         -#define Tcl_ExprBooleanObj(interp, objPtr, ptr) \
  1994         -	(tclStubsPtr->tcl_ExprBooleanObj)(interp, objPtr, ptr) /* 136 */
         1993  +#define Tcl_ExprBooleanObj \
         1994  +	(tclStubsPtr->tcl_ExprBooleanObj) /* 136 */
  1995   1995   #endif
  1996   1996   #ifndef Tcl_ExprDouble
  1997         -#define Tcl_ExprDouble(interp, str, ptr) \
  1998         -	(tclStubsPtr->tcl_ExprDouble)(interp, str, ptr) /* 137 */
         1997  +#define Tcl_ExprDouble \
         1998  +	(tclStubsPtr->tcl_ExprDouble) /* 137 */
  1999   1999   #endif
  2000   2000   #ifndef Tcl_ExprDoubleObj
  2001         -#define Tcl_ExprDoubleObj(interp, objPtr, ptr) \
  2002         -	(tclStubsPtr->tcl_ExprDoubleObj)(interp, objPtr, ptr) /* 138 */
         2001  +#define Tcl_ExprDoubleObj \
         2002  +	(tclStubsPtr->tcl_ExprDoubleObj) /* 138 */
  2003   2003   #endif
  2004   2004   #ifndef Tcl_ExprLong
  2005         -#define Tcl_ExprLong(interp, str, ptr) \
  2006         -	(tclStubsPtr->tcl_ExprLong)(interp, str, ptr) /* 139 */
         2005  +#define Tcl_ExprLong \
         2006  +	(tclStubsPtr->tcl_ExprLong) /* 139 */
  2007   2007   #endif
  2008   2008   #ifndef Tcl_ExprLongObj
  2009         -#define Tcl_ExprLongObj(interp, objPtr, ptr) \
  2010         -	(tclStubsPtr->tcl_ExprLongObj)(interp, objPtr, ptr) /* 140 */
         2009  +#define Tcl_ExprLongObj \
         2010  +	(tclStubsPtr->tcl_ExprLongObj) /* 140 */
  2011   2011   #endif
  2012   2012   #ifndef Tcl_ExprObj
  2013         -#define Tcl_ExprObj(interp, objPtr, resultPtrPtr) \
  2014         -	(tclStubsPtr->tcl_ExprObj)(interp, objPtr, resultPtrPtr) /* 141 */
         2013  +#define Tcl_ExprObj \
         2014  +	(tclStubsPtr->tcl_ExprObj) /* 141 */
  2015   2015   #endif
  2016   2016   #ifndef Tcl_ExprString
  2017         -#define Tcl_ExprString(interp, string) \
  2018         -	(tclStubsPtr->tcl_ExprString)(interp, string) /* 142 */
         2017  +#define Tcl_ExprString \
         2018  +	(tclStubsPtr->tcl_ExprString) /* 142 */
  2019   2019   #endif
  2020   2020   #ifndef Tcl_Finalize
  2021         -#define Tcl_Finalize() \
  2022         -	(tclStubsPtr->tcl_Finalize)() /* 143 */
         2021  +#define Tcl_Finalize \
         2022  +	(tclStubsPtr->tcl_Finalize) /* 143 */
  2023   2023   #endif
  2024   2024   #ifndef Tcl_FindExecutable
  2025         -#define Tcl_FindExecutable(argv0) \
  2026         -	(tclStubsPtr->tcl_FindExecutable)(argv0) /* 144 */
         2025  +#define Tcl_FindExecutable \
         2026  +	(tclStubsPtr->tcl_FindExecutable) /* 144 */
  2027   2027   #endif
  2028   2028   #ifndef Tcl_FirstHashEntry
  2029         -#define Tcl_FirstHashEntry(tablePtr, searchPtr) \
  2030         -	(tclStubsPtr->tcl_FirstHashEntry)(tablePtr, searchPtr) /* 145 */
         2029  +#define Tcl_FirstHashEntry \
         2030  +	(tclStubsPtr->tcl_FirstHashEntry) /* 145 */
  2031   2031   #endif
  2032   2032   #ifndef Tcl_Flush
  2033         -#define Tcl_Flush(chan) \
  2034         -	(tclStubsPtr->tcl_Flush)(chan) /* 146 */
         2033  +#define Tcl_Flush \
         2034  +	(tclStubsPtr->tcl_Flush) /* 146 */
  2035   2035   #endif
  2036   2036   #ifndef Tcl_FreeResult
  2037         -#define Tcl_FreeResult(interp) \
  2038         -	(tclStubsPtr->tcl_FreeResult)(interp) /* 147 */
         2037  +#define Tcl_FreeResult \
         2038  +	(tclStubsPtr->tcl_FreeResult) /* 147 */
  2039   2039   #endif
  2040   2040   #ifndef Tcl_GetAlias
  2041         -#define Tcl_GetAlias(interp, slaveCmd, targetInterpPtr, targetCmdPtr, argcPtr, argvPtr) \
  2042         -	(tclStubsPtr->tcl_GetAlias)(interp, slaveCmd, targetInterpPtr, targetCmdPtr, argcPtr, argvPtr) /* 148 */
         2041  +#define Tcl_GetAlias \
         2042  +	(tclStubsPtr->tcl_GetAlias) /* 148 */
  2043   2043   #endif
  2044   2044   #ifndef Tcl_GetAliasObj
  2045         -#define Tcl_GetAliasObj(interp, slaveCmd, targetInterpPtr, targetCmdPtr, objcPtr, objv) \
  2046         -	(tclStubsPtr->tcl_GetAliasObj)(interp, slaveCmd, targetInterpPtr, targetCmdPtr, objcPtr, objv) /* 149 */
         2045  +#define Tcl_GetAliasObj \
         2046  +	(tclStubsPtr->tcl_GetAliasObj) /* 149 */
  2047   2047   #endif
  2048   2048   #ifndef Tcl_GetAssocData
  2049         -#define Tcl_GetAssocData(interp, name, procPtr) \
  2050         -	(tclStubsPtr->tcl_GetAssocData)(interp, name, procPtr) /* 150 */
         2049  +#define Tcl_GetAssocData \
         2050  +	(tclStubsPtr->tcl_GetAssocData) /* 150 */
  2051   2051   #endif
  2052   2052   #ifndef Tcl_GetChannel
  2053         -#define Tcl_GetChannel(interp, chanName, modePtr) \
  2054         -	(tclStubsPtr->tcl_GetChannel)(interp, chanName, modePtr) /* 151 */
         2053  +#define Tcl_GetChannel \
         2054  +	(tclStubsPtr->tcl_GetChannel) /* 151 */
  2055   2055   #endif
  2056   2056   #ifndef Tcl_GetChannelBufferSize
  2057         -#define Tcl_GetChannelBufferSize(chan) \
  2058         -	(tclStubsPtr->tcl_GetChannelBufferSize)(chan) /* 152 */
         2057  +#define Tcl_GetChannelBufferSize \
         2058  +	(tclStubsPtr->tcl_GetChannelBufferSize) /* 152 */
  2059   2059   #endif
  2060   2060   #ifndef Tcl_GetChannelHandle
  2061         -#define Tcl_GetChannelHandle(chan, direction, handlePtr) \
  2062         -	(tclStubsPtr->tcl_GetChannelHandle)(chan, direction, handlePtr) /* 153 */
         2061  +#define Tcl_GetChannelHandle \
         2062  +	(tclStubsPtr->tcl_GetChannelHandle) /* 153 */
  2063   2063   #endif
  2064   2064   #ifndef Tcl_GetChannelInstanceData
  2065         -#define Tcl_GetChannelInstanceData(chan) \
  2066         -	(tclStubsPtr->tcl_GetChannelInstanceData)(chan) /* 154 */
         2065  +#define Tcl_GetChannelInstanceData \
         2066  +	(tclStubsPtr->tcl_GetChannelInstanceData) /* 154 */
  2067   2067   #endif
  2068   2068   #ifndef Tcl_GetChannelMode
  2069         -#define Tcl_GetChannelMode(chan) \
  2070         -	(tclStubsPtr->tcl_GetChannelMode)(chan) /* 155 */
         2069  +#define Tcl_GetChannelMode \
         2070  +	(tclStubsPtr->tcl_GetChannelMode) /* 155 */
  2071   2071   #endif
  2072   2072   #ifndef Tcl_GetChannelName
  2073         -#define Tcl_GetChannelName(chan) \
  2074         -	(tclStubsPtr->tcl_GetChannelName)(chan) /* 156 */
         2073  +#define Tcl_GetChannelName \
         2074  +	(tclStubsPtr->tcl_GetChannelName) /* 156 */
  2075   2075   #endif
  2076   2076   #ifndef Tcl_GetChannelOption
  2077         -#define Tcl_GetChannelOption(interp, chan, optionName, dsPtr) \
  2078         -	(tclStubsPtr->tcl_GetChannelOption)(interp, chan, optionName, dsPtr) /* 157 */
         2077  +#define Tcl_GetChannelOption \
         2078  +	(tclStubsPtr->tcl_GetChannelOption) /* 157 */
  2079   2079   #endif
  2080   2080   #ifndef Tcl_GetChannelType
  2081         -#define Tcl_GetChannelType(chan) \
  2082         -	(tclStubsPtr->tcl_GetChannelType)(chan) /* 158 */
         2081  +#define Tcl_GetChannelType \
         2082  +	(tclStubsPtr->tcl_GetChannelType) /* 158 */
  2083   2083   #endif
  2084   2084   #ifndef Tcl_GetCommandInfo
  2085         -#define Tcl_GetCommandInfo(interp, cmdName, infoPtr) \
  2086         -	(tclStubsPtr->tcl_GetCommandInfo)(interp, cmdName, infoPtr) /* 159 */
         2085  +#define Tcl_GetCommandInfo \
         2086  +	(tclStubsPtr->tcl_GetCommandInfo) /* 159 */
  2087   2087   #endif
  2088   2088   #ifndef Tcl_GetCommandName
  2089         -#define Tcl_GetCommandName(interp, command) \
  2090         -	(tclStubsPtr->tcl_GetCommandName)(interp, command) /* 160 */
         2089  +#define Tcl_GetCommandName \
         2090  +	(tclStubsPtr->tcl_GetCommandName) /* 160 */
  2091   2091   #endif
  2092   2092   #ifndef Tcl_GetErrno
  2093         -#define Tcl_GetErrno() \
  2094         -	(tclStubsPtr->tcl_GetErrno)() /* 161 */
         2093  +#define Tcl_GetErrno \
         2094  +	(tclStubsPtr->tcl_GetErrno) /* 161 */
  2095   2095   #endif
  2096   2096   #ifndef Tcl_GetHostName
  2097         -#define Tcl_GetHostName() \
  2098         -	(tclStubsPtr->tcl_GetHostName)() /* 162 */
         2097  +#define Tcl_GetHostName \
         2098  +	(tclStubsPtr->tcl_GetHostName) /* 162 */
  2099   2099   #endif
  2100   2100   #ifndef Tcl_GetInterpPath
  2101         -#define Tcl_GetInterpPath(askInterp, slaveInterp) \
  2102         -	(tclStubsPtr->tcl_GetInterpPath)(askInterp, slaveInterp) /* 163 */
         2101  +#define Tcl_GetInterpPath \
         2102  +	(tclStubsPtr->tcl_GetInterpPath) /* 163 */
  2103   2103   #endif
  2104   2104   #ifndef Tcl_GetMaster
  2105         -#define Tcl_GetMaster(interp) \
  2106         -	(tclStubsPtr->tcl_GetMaster)(interp) /* 164 */
         2105  +#define Tcl_GetMaster \
         2106  +	(tclStubsPtr->tcl_GetMaster) /* 164 */
  2107   2107   #endif
  2108   2108   #ifndef Tcl_GetNameOfExecutable
  2109         -#define Tcl_GetNameOfExecutable() \
  2110         -	(tclStubsPtr->tcl_GetNameOfExecutable)() /* 165 */
         2109  +#define Tcl_GetNameOfExecutable \
         2110  +	(tclStubsPtr->tcl_GetNameOfExecutable) /* 165 */
  2111   2111   #endif
  2112   2112   #ifndef Tcl_GetObjResult
  2113         -#define Tcl_GetObjResult(interp) \
  2114         -	(tclStubsPtr->tcl_GetObjResult)(interp) /* 166 */
         2113  +#define Tcl_GetObjResult \
         2114  +	(tclStubsPtr->tcl_GetObjResult) /* 166 */
  2115   2115   #endif
  2116   2116   #if !defined(__WIN32__) && !defined(MAC_TCL) /* UNIX */
  2117   2117   #ifndef Tcl_GetOpenFile
  2118         -#define Tcl_GetOpenFile(interp, str, write, checkUsage, filePtr) \
  2119         -	(tclStubsPtr->tcl_GetOpenFile)(interp, str, write, checkUsage, filePtr) /* 167 */
         2118  +#define Tcl_GetOpenFile \
         2119  +	(tclStubsPtr->tcl_GetOpenFile) /* 167 */
  2120   2120   #endif
  2121   2121   #endif /* UNIX */
  2122   2122   #ifndef Tcl_GetPathType
  2123         -#define Tcl_GetPathType(path) \
  2124         -	(tclStubsPtr->tcl_GetPathType)(path) /* 168 */
         2123  +#define Tcl_GetPathType \
         2124  +	(tclStubsPtr->tcl_GetPathType) /* 168 */
  2125   2125   #endif
  2126   2126   #ifndef Tcl_Gets
  2127         -#define Tcl_Gets(chan, dsPtr) \
  2128         -	(tclStubsPtr->tcl_Gets)(chan, dsPtr) /* 169 */
         2127  +#define Tcl_Gets \
         2128  +	(tclStubsPtr->tcl_Gets) /* 169 */
  2129   2129   #endif
  2130   2130   #ifndef Tcl_GetsObj
  2131         -#define Tcl_GetsObj(chan, objPtr) \
  2132         -	(tclStubsPtr->tcl_GetsObj)(chan, objPtr) /* 170 */
         2131  +#define Tcl_GetsObj \
         2132  +	(tclStubsPtr->tcl_GetsObj) /* 170 */
  2133   2133   #endif
  2134   2134   #ifndef Tcl_GetServiceMode
  2135         -#define Tcl_GetServiceMode() \
  2136         -	(tclStubsPtr->tcl_GetServiceMode)() /* 171 */
         2135  +#define Tcl_GetServiceMode \
         2136  +	(tclStubsPtr->tcl_GetServiceMode) /* 171 */
  2137   2137   #endif
  2138   2138   #ifndef Tcl_GetSlave
  2139         -#define Tcl_GetSlave(interp, slaveName) \
  2140         -	(tclStubsPtr->tcl_GetSlave)(interp, slaveName) /* 172 */
         2139  +#define Tcl_GetSlave \
         2140  +	(tclStubsPtr->tcl_GetSlave) /* 172 */
  2141   2141   #endif
  2142   2142   #ifndef Tcl_GetStdChannel
  2143         -#define Tcl_GetStdChannel(type) \
  2144         -	(tclStubsPtr->tcl_GetStdChannel)(type) /* 173 */
         2143  +#define Tcl_GetStdChannel \
         2144  +	(tclStubsPtr->tcl_GetStdChannel) /* 173 */
  2145   2145   #endif
  2146   2146   #ifndef Tcl_GetStringResult
  2147         -#define Tcl_GetStringResult(interp) \
  2148         -	(tclStubsPtr->tcl_GetStringResult)(interp) /* 174 */
         2147  +#define Tcl_GetStringResult \
         2148  +	(tclStubsPtr->tcl_GetStringResult) /* 174 */
  2149   2149   #endif
  2150   2150   #ifndef Tcl_GetVar
  2151         -#define Tcl_GetVar(interp, varName, flags) \
  2152         -	(tclStubsPtr->tcl_GetVar)(interp, varName, flags) /* 175 */
         2151  +#define Tcl_GetVar \
         2152  +	(tclStubsPtr->tcl_GetVar) /* 175 */
  2153   2153   #endif
  2154   2154   #ifndef Tcl_GetVar2
  2155         -#define Tcl_GetVar2(interp, part1, part2, flags) \
  2156         -	(tclStubsPtr->tcl_GetVar2)(interp, part1, part2, flags) /* 176 */
         2155  +#define Tcl_GetVar2 \
         2156  +	(tclStubsPtr->tcl_GetVar2) /* 176 */
  2157   2157   #endif
  2158   2158   #ifndef Tcl_GlobalEval
  2159         -#define Tcl_GlobalEval(interp, command) \
  2160         -	(tclStubsPtr->tcl_GlobalEval)(interp, command) /* 177 */
         2159  +#define Tcl_GlobalEval \
         2160  +	(tclStubsPtr->tcl_GlobalEval) /* 177 */
  2161   2161   #endif
  2162   2162   #ifndef Tcl_GlobalEvalObj
  2163         -#define Tcl_GlobalEvalObj(interp, objPtr) \
  2164         -	(tclStubsPtr->tcl_GlobalEvalObj)(interp, objPtr) /* 178 */
         2163  +#define Tcl_GlobalEvalObj \
         2164  +	(tclStubsPtr->tcl_GlobalEvalObj) /* 178 */
  2165   2165   #endif
  2166   2166   #ifndef Tcl_HideCommand
  2167         -#define Tcl_HideCommand(interp, cmdName, hiddenCmdToken) \
  2168         -	(tclStubsPtr->tcl_HideCommand)(interp, cmdName, hiddenCmdToken) /* 179 */
         2167  +#define Tcl_HideCommand \
         2168  +	(tclStubsPtr->tcl_HideCommand) /* 179 */
  2169   2169   #endif
  2170   2170   #ifndef Tcl_Init
  2171         -#define Tcl_Init(interp) \
  2172         -	(tclStubsPtr->tcl_Init)(interp) /* 180 */
         2171  +#define Tcl_Init \
         2172  +	(tclStubsPtr->tcl_Init) /* 180 */
  2173   2173   #endif
  2174   2174   #ifndef Tcl_InitHashTable
  2175         -#define Tcl_InitHashTable(tablePtr, keyType) \
  2176         -	(tclStubsPtr->tcl_InitHashTable)(tablePtr, keyType) /* 181 */
         2175  +#define Tcl_InitHashTable \
         2176  +	(tclStubsPtr->tcl_InitHashTable) /* 181 */
  2177   2177   #endif
  2178   2178   #ifndef Tcl_InputBlocked
  2179         -#define Tcl_InputBlocked(chan) \
  2180         -	(tclStubsPtr->tcl_InputBlocked)(chan) /* 182 */
         2179  +#define Tcl_InputBlocked \
         2180  +	(tclStubsPtr->tcl_InputBlocked) /* 182 */
  2181   2181   #endif
  2182   2182   #ifndef Tcl_InputBuffered
  2183         -#define Tcl_InputBuffered(chan) \
  2184         -	(tclStubsPtr->tcl_InputBuffered)(chan) /* 183 */
         2183  +#define Tcl_InputBuffered \
         2184  +	(tclStubsPtr->tcl_InputBuffered) /* 183 */
  2185   2185   #endif
  2186   2186   #ifndef Tcl_InterpDeleted
  2187         -#define Tcl_InterpDeleted(interp) \
  2188         -	(tclStubsPtr->tcl_InterpDeleted)(interp) /* 184 */
         2187  +#define Tcl_InterpDeleted \
         2188  +	(tclStubsPtr->tcl_InterpDeleted) /* 184 */
  2189   2189   #endif
  2190   2190   #ifndef Tcl_IsSafe
  2191         -#define Tcl_IsSafe(interp) \
  2192         -	(tclStubsPtr->tcl_IsSafe)(interp) /* 185 */
         2191  +#define Tcl_IsSafe \
         2192  +	(tclStubsPtr->tcl_IsSafe) /* 185 */
  2193   2193   #endif
  2194   2194   #ifndef Tcl_JoinPath
  2195         -#define Tcl_JoinPath(argc, argv, resultPtr) \
  2196         -	(tclStubsPtr->tcl_JoinPath)(argc, argv, resultPtr) /* 186 */
         2195  +#define Tcl_JoinPath \
         2196  +	(tclStubsPtr->tcl_JoinPath) /* 186 */
  2197   2197   #endif
  2198   2198   #ifndef Tcl_LinkVar
  2199         -#define Tcl_LinkVar(interp, varName, addr, type) \
  2200         -	(tclStubsPtr->tcl_LinkVar)(interp, varName, addr, type) /* 187 */
         2199  +#define Tcl_LinkVar \
         2200  +	(tclStubsPtr->tcl_LinkVar) /* 187 */
  2201   2201   #endif
  2202   2202   /* Slot 188 is reserved */
  2203   2203   #ifndef Tcl_MakeFileChannel
  2204         -#define Tcl_MakeFileChannel(handle, mode) \
  2205         -	(tclStubsPtr->tcl_MakeFileChannel)(handle, mode) /* 189 */
         2204  +#define Tcl_MakeFileChannel \
         2205  +	(tclStubsPtr->tcl_MakeFileChannel) /* 189 */
  2206   2206   #endif
  2207   2207   #ifndef Tcl_MakeSafe
  2208         -#define Tcl_MakeSafe(interp) \
  2209         -	(tclStubsPtr->tcl_MakeSafe)(interp) /* 190 */
         2208  +#define Tcl_MakeSafe \
         2209  +	(tclStubsPtr->tcl_MakeSafe) /* 190 */
  2210   2210   #endif
  2211   2211   #ifndef Tcl_MakeTcpClientChannel
  2212         -#define Tcl_MakeTcpClientChannel(tcpSocket) \
  2213         -	(tclStubsPtr->tcl_MakeTcpClientChannel)(tcpSocket) /* 191 */
         2212  +#define Tcl_MakeTcpClientChannel \
         2213  +	(tclStubsPtr->tcl_MakeTcpClientChannel) /* 191 */
  2214   2214   #endif
  2215   2215   #ifndef Tcl_Merge
  2216         -#define Tcl_Merge(argc, argv) \
  2217         -	(tclStubsPtr->tcl_Merge)(argc, argv) /* 192 */
         2216  +#define Tcl_Merge \
         2217  +	(tclStubsPtr->tcl_Merge) /* 192 */
  2218   2218   #endif
  2219   2219   #ifndef Tcl_NextHashEntry
  2220         -#define Tcl_NextHashEntry(searchPtr) \
  2221         -	(tclStubsPtr->tcl_NextHashEntry)(searchPtr) /* 193 */
         2220  +#define Tcl_NextHashEntry \
         2221  +	(tclStubsPtr->tcl_NextHashEntry) /* 193 */
  2222   2222   #endif
  2223   2223   #ifndef Tcl_NotifyChannel
  2224         -#define Tcl_NotifyChannel(channel, mask) \
  2225         -	(tclStubsPtr->tcl_NotifyChannel)(channel, mask) /* 194 */
         2224  +#define Tcl_NotifyChannel \
         2225  +	(tclStubsPtr->tcl_NotifyChannel) /* 194 */
  2226   2226   #endif
  2227   2227   #ifndef Tcl_ObjGetVar2
  2228         -#define Tcl_ObjGetVar2(interp, part1Ptr, part2Ptr, flags) \
  2229         -	(tclStubsPtr->tcl_ObjGetVar2)(interp, part1Ptr, part2Ptr, flags) /* 195 */
         2228  +#define Tcl_ObjGetVar2 \
         2229  +	(tclStubsPtr->tcl_ObjGetVar2) /* 195 */
  2230   2230   #endif
  2231   2231   #ifndef Tcl_ObjSetVar2
  2232         -#define Tcl_ObjSetVar2(interp, part1Ptr, part2Ptr, newValuePtr, flags) \
  2233         -	(tclStubsPtr->tcl_ObjSetVar2)(interp, part1Ptr, part2Ptr, newValuePtr, flags) /* 196 */
         2232  +#define Tcl_ObjSetVar2 \
         2233  +	(tclStubsPtr->tcl_ObjSetVar2) /* 196 */
  2234   2234   #endif
  2235   2235   #ifndef Tcl_OpenCommandChannel
  2236         -#define Tcl_OpenCommandChannel(interp, argc, argv, flags) \
  2237         -	(tclStubsPtr->tcl_OpenCommandChannel)(interp, argc, argv, flags) /* 197 */
         2236  +#define Tcl_OpenCommandChannel \
         2237  +	(tclStubsPtr->tcl_OpenCommandChannel) /* 197 */
  2238   2238   #endif
  2239   2239   #ifndef Tcl_OpenFileChannel
  2240         -#define Tcl_OpenFileChannel(interp, fileName, modeString, permissions) \
  2241         -	(tclStubsPtr->tcl_OpenFileChannel)(interp, fileName, modeString, permissions) /* 198 */
         2240  +#define Tcl_OpenFileChannel \
         2241  +	(tclStubsPtr->tcl_OpenFileChannel) /* 198 */
  2242   2242   #endif
  2243   2243   #ifndef Tcl_OpenTcpClient
  2244         -#define Tcl_OpenTcpClient(interp, port, address, myaddr, myport, async) \
  2245         -	(tclStubsPtr->tcl_OpenTcpClient)(interp, port, address, myaddr, myport, async) /* 199 */
         2244  +#define Tcl_OpenTcpClient \
         2245  +	(tclStubsPtr->tcl_OpenTcpClient) /* 199 */
  2246   2246   #endif
  2247   2247   #ifndef Tcl_OpenTcpServer
  2248         -#define Tcl_OpenTcpServer(interp, port, host, acceptProc, callbackData) \
  2249         -	(tclStubsPtr->tcl_OpenTcpServer)(interp, port, host, acceptProc, callbackData) /* 200 */
         2248  +#define Tcl_OpenTcpServer \
         2249  +	(tclStubsPtr->tcl_OpenTcpServer) /* 200 */
  2250   2250   #endif
  2251   2251   #ifndef Tcl_Preserve
  2252         -#define Tcl_Preserve(data) \
  2253         -	(tclStubsPtr->tcl_Preserve)(data) /* 201 */
         2252  +#define Tcl_Preserve \
         2253  +	(tclStubsPtr->tcl_Preserve) /* 201 */
  2254   2254   #endif
  2255   2255   #ifndef Tcl_PrintDouble
  2256         -#define Tcl_PrintDouble(interp, value, dst) \
  2257         -	(tclStubsPtr->tcl_PrintDouble)(interp, value, dst) /* 202 */
         2256  +#define Tcl_PrintDouble \
         2257  +	(tclStubsPtr->tcl_PrintDouble) /* 202 */
  2258   2258   #endif
  2259   2259   #ifndef Tcl_PutEnv
  2260         -#define Tcl_PutEnv(string) \
  2261         -	(tclStubsPtr->tcl_PutEnv)(string) /* 203 */
         2260  +#define Tcl_PutEnv \
         2261  +	(tclStubsPtr->tcl_PutEnv) /* 203 */
  2262   2262   #endif
  2263   2263   #ifndef Tcl_PosixError
  2264         -#define Tcl_PosixError(interp) \
  2265         -	(tclStubsPtr->tcl_PosixError)(interp) /* 204 */
         2264  +#define Tcl_PosixError \
         2265  +	(tclStubsPtr->tcl_PosixError) /* 204 */
  2266   2266   #endif
  2267   2267   #ifndef Tcl_QueueEvent
  2268         -#define Tcl_QueueEvent(evPtr, position) \
  2269         -	(tclStubsPtr->tcl_QueueEvent)(evPtr, position) /* 205 */
         2268  +#define Tcl_QueueEvent \
         2269  +	(tclStubsPtr->tcl_QueueEvent) /* 205 */
  2270   2270   #endif
  2271   2271   #ifndef Tcl_Read
  2272         -#define Tcl_Read(chan, bufPtr, toRead) \
  2273         -	(tclStubsPtr->tcl_Read)(chan, bufPtr, toRead) /* 206 */
         2272  +#define Tcl_Read \
         2273  +	(tclStubsPtr->tcl_Read) /* 206 */
  2274   2274   #endif
  2275   2275   #ifndef Tcl_ReapDetachedProcs
  2276         -#define Tcl_ReapDetachedProcs() \
  2277         -	(tclStubsPtr->tcl_ReapDetachedProcs)() /* 207 */
         2276  +#define Tcl_ReapDetachedProcs \
         2277  +	(tclStubsPtr->tcl_ReapDetachedProcs) /* 207 */
  2278   2278   #endif
  2279   2279   #ifndef Tcl_RecordAndEval
  2280         -#define Tcl_RecordAndEval(interp, cmd, flags) \
  2281         -	(tclStubsPtr->tcl_RecordAndEval)(interp, cmd, flags) /* 208 */
         2280  +#define Tcl_RecordAndEval \
         2281  +	(tclStubsPtr->tcl_RecordAndEval) /* 208 */
  2282   2282   #endif
  2283   2283   #ifndef Tcl_RecordAndEvalObj
  2284         -#define Tcl_RecordAndEvalObj(interp, cmdPtr, flags) \
  2285         -	(tclStubsPtr->tcl_RecordAndEvalObj)(interp, cmdPtr, flags) /* 209 */
         2284  +#define Tcl_RecordAndEvalObj \
         2285  +	(tclStubsPtr->tcl_RecordAndEvalObj) /* 209 */
  2286   2286   #endif
  2287   2287   #ifndef Tcl_RegisterChannel
  2288         -#define Tcl_RegisterChannel(interp, chan) \
  2289         -	(tclStubsPtr->tcl_RegisterChannel)(interp, chan) /* 210 */
         2288  +#define Tcl_RegisterChannel \
         2289  +	(tclStubsPtr->tcl_RegisterChannel) /* 210 */
  2290   2290   #endif
  2291   2291   #ifndef Tcl_RegisterObjType
  2292         -#define Tcl_RegisterObjType(typePtr) \
  2293         -	(tclStubsPtr->tcl_RegisterObjType)(typePtr) /* 211 */
         2292  +#define Tcl_RegisterObjType \
         2293  +	(tclStubsPtr->tcl_RegisterObjType) /* 211 */
  2294   2294   #endif
  2295   2295   #ifndef Tcl_RegExpCompile
  2296         -#define Tcl_RegExpCompile(interp, string) \
  2297         -	(tclStubsPtr->tcl_RegExpCompile)(interp, string) /* 212 */
         2296  +#define Tcl_RegExpCompile \
         2297  +	(tclStubsPtr->tcl_RegExpCompile) /* 212 */
  2298   2298   #endif
  2299   2299   #ifndef Tcl_RegExpExec
  2300         -#define Tcl_RegExpExec(interp, regexp, str, start) \
  2301         -	(tclStubsPtr->tcl_RegExpExec)(interp, regexp, str, start) /* 213 */
         2300  +#define Tcl_RegExpExec \
         2301  +	(tclStubsPtr->tcl_RegExpExec) /* 213 */
  2302   2302   #endif
  2303   2303   #ifndef Tcl_RegExpMatch
  2304         -#define Tcl_RegExpMatch(interp, str, pattern) \
  2305         -	(tclStubsPtr->tcl_RegExpMatch)(interp, str, pattern) /* 214 */
         2304  +#define Tcl_RegExpMatch \
         2305  +	(tclStubsPtr->tcl_RegExpMatch) /* 214 */
  2306   2306   #endif
  2307   2307   #ifndef Tcl_RegExpRange
  2308         -#define Tcl_RegExpRange(regexp, index, startPtr, endPtr) \
  2309         -	(tclStubsPtr->tcl_RegExpRange)(regexp, index, startPtr, endPtr) /* 215 */
         2308  +#define Tcl_RegExpRange \
         2309  +	(tclStubsPtr->tcl_RegExpRange) /* 215 */
  2310   2310   #endif
  2311   2311   #ifndef Tcl_Release
  2312         -#define Tcl_Release(clientData) \
  2313         -	(tclStubsPtr->tcl_Release)(clientData) /* 216 */
         2312  +#define Tcl_Release \
         2313  +	(tclStubsPtr->tcl_Release) /* 216 */
  2314   2314   #endif
  2315   2315   #ifndef Tcl_ResetResult
  2316         -#define Tcl_ResetResult(interp) \
  2317         -	(tclStubsPtr->tcl_ResetResult)(interp) /* 217 */
         2316  +#define Tcl_ResetResult \
         2317  +	(tclStubsPtr->tcl_ResetResult) /* 217 */
  2318   2318   #endif
  2319   2319   #ifndef Tcl_ScanElement
  2320         -#define Tcl_ScanElement(str, flagPtr) \
  2321         -	(tclStubsPtr->tcl_ScanElement)(str, flagPtr) /* 218 */
         2320  +#define Tcl_ScanElement \
         2321  +	(tclStubsPtr->tcl_ScanElement) /* 218 */
  2322   2322   #endif
  2323   2323   #ifndef Tcl_ScanCountedElement
  2324         -#define Tcl_ScanCountedElement(str, length, flagPtr) \
  2325         -	(tclStubsPtr->tcl_ScanCountedElement)(str, length, flagPtr) /* 219 */
         2324  +#define Tcl_ScanCountedElement \
         2325  +	(tclStubsPtr->tcl_ScanCountedElement) /* 219 */
  2326   2326   #endif
  2327   2327   #ifndef Tcl_Seek
  2328         -#define Tcl_Seek(chan, offset, mode) \
  2329         -	(tclStubsPtr->tcl_Seek)(chan, offset, mode) /* 220 */
         2328  +#define Tcl_Seek \
         2329  +	(tclStubsPtr->tcl_Seek) /* 220 */
  2330   2330   #endif
  2331   2331   #ifndef Tcl_ServiceAll
  2332         -#define Tcl_ServiceAll() \
  2333         -	(tclStubsPtr->tcl_ServiceAll)() /* 221 */
         2332  +#define Tcl_ServiceAll \
         2333  +	(tclStubsPtr->tcl_ServiceAll) /* 221 */
  2334   2334   #endif
  2335   2335   #ifndef Tcl_ServiceEvent
  2336         -#define Tcl_ServiceEvent(flags) \
  2337         -	(tclStubsPtr->tcl_ServiceEvent)(flags) /* 222 */
         2336  +#define Tcl_ServiceEvent \
         2337  +	(tclStubsPtr->tcl_ServiceEvent) /* 222 */
  2338   2338   #endif
  2339   2339   #ifndef Tcl_SetAssocData
  2340         -#define Tcl_SetAssocData(interp, name, proc, clientData) \
  2341         -	(tclStubsPtr->tcl_SetAssocData)(interp, name, proc, clientData) /* 223 */
         2340  +#define Tcl_SetAssocData \
         2341  +	(tclStubsPtr->tcl_SetAssocData) /* 223 */
  2342   2342   #endif
  2343   2343   #ifndef Tcl_SetChannelBufferSize
  2344         -#define Tcl_SetChannelBufferSize(chan, sz) \
  2345         -	(tclStubsPtr->tcl_SetChannelBufferSize)(chan, sz) /* 224 */
         2344  +#define Tcl_SetChannelBufferSize \
         2345  +	(tclStubsPtr->tcl_SetChannelBufferSize) /* 224 */
  2346   2346   #endif
  2347   2347   #ifndef Tcl_SetChannelOption
  2348         -#define Tcl_SetChannelOption(interp, chan, optionName, newValue) \
  2349         -	(tclStubsPtr->tcl_SetChannelOption)(interp, chan, optionName, newValue) /* 225 */
         2348  +#define Tcl_SetChannelOption \
         2349  +	(tclStubsPtr->tcl_SetChannelOption) /* 225 */
  2350   2350   #endif
  2351   2351   #ifndef Tcl_SetCommandInfo
  2352         -#define Tcl_SetCommandInfo(interp, cmdName, infoPtr) \
  2353         -	(tclStubsPtr->tcl_SetCommandInfo)(interp, cmdName, infoPtr) /* 226 */
         2352  +#define Tcl_SetCommandInfo \
         2353  +	(tclStubsPtr->tcl_SetCommandInfo) /* 226 */
  2354   2354   #endif
  2355   2355   #ifndef Tcl_SetErrno
  2356         -#define Tcl_SetErrno(err) \
  2357         -	(tclStubsPtr->tcl_SetErrno)(err) /* 227 */
         2356  +#define Tcl_SetErrno \
         2357  +	(tclStubsPtr->tcl_SetErrno) /* 227 */
  2358   2358   #endif
  2359   2359   #ifndef Tcl_SetErrorCode
  2360   2360   #define Tcl_SetErrorCode \
  2361   2361   	(tclStubsPtr->tcl_SetErrorCode) /* 228 */
  2362   2362   #endif
  2363   2363   #ifndef Tcl_SetMaxBlockTime
  2364         -#define Tcl_SetMaxBlockTime(timePtr) \
  2365         -	(tclStubsPtr->tcl_SetMaxBlockTime)(timePtr) /* 229 */
         2364  +#define Tcl_SetMaxBlockTime \
         2365  +	(tclStubsPtr->tcl_SetMaxBlockTime) /* 229 */
  2366   2366   #endif
  2367   2367   #ifndef Tcl_SetPanicProc
  2368         -#define Tcl_SetPanicProc(panicProc) \
  2369         -	(tclStubsPtr->tcl_SetPanicProc)(panicProc) /* 230 */
         2368  +#define Tcl_SetPanicProc \
         2369  +	(tclStubsPtr->tcl_SetPanicProc) /* 230 */
  2370   2370   #endif
  2371   2371   #ifndef Tcl_SetRecursionLimit
  2372         -#define Tcl_SetRecursionLimit(interp, depth) \
  2373         -	(tclStubsPtr->tcl_SetRecursionLimit)(interp, depth) /* 231 */
         2372  +#define Tcl_SetRecursionLimit \
         2373  +	(tclStubsPtr->tcl_SetRecursionLimit) /* 231 */
  2374   2374   #endif
  2375   2375   #ifndef Tcl_SetResult
  2376         -#define Tcl_SetResult(interp, str, freeProc) \
  2377         -	(tclStubsPtr->tcl_SetResult)(interp, str, freeProc) /* 232 */
         2376  +#define Tcl_SetResult \
         2377  +	(tclStubsPtr->tcl_SetResult) /* 232 */
  2378   2378   #endif
  2379   2379   #ifndef Tcl_SetServiceMode
  2380         -#define Tcl_SetServiceMode(mode) \
  2381         -	(tclStubsPtr->tcl_SetServiceMode)(mode) /* 233 */
         2380  +#define Tcl_SetServiceMode \
         2381  +	(tclStubsPtr->tcl_SetServiceMode) /* 233 */
  2382   2382   #endif
  2383   2383   #ifndef Tcl_SetObjErrorCode
  2384         -#define Tcl_SetObjErrorCode(interp, errorObjPtr) \
  2385         -	(tclStubsPtr->tcl_SetObjErrorCode)(interp, errorObjPtr) /* 234 */
         2384  +#define Tcl_SetObjErrorCode \
         2385  +	(tclStubsPtr->tcl_SetObjErrorCode) /* 234 */
  2386   2386   #endif
  2387   2387   #ifndef Tcl_SetObjResult
  2388         -#define Tcl_SetObjResult(interp, resultObjPtr) \
  2389         -	(tclStubsPtr->tcl_SetObjResult)(interp, resultObjPtr) /* 235 */
         2388  +#define Tcl_SetObjResult \
         2389  +	(tclStubsPtr->tcl_SetObjResult) /* 235 */
  2390   2390   #endif
  2391   2391   #ifndef Tcl_SetStdChannel
  2392         -#define Tcl_SetStdChannel(channel, type) \
  2393         -	(tclStubsPtr->tcl_SetStdChannel)(channel, type) /* 236 */
         2392  +#define Tcl_SetStdChannel \
         2393  +	(tclStubsPtr->tcl_SetStdChannel) /* 236 */
  2394   2394   #endif
  2395   2395   #ifndef Tcl_SetVar
  2396         -#define Tcl_SetVar(interp, varName, newValue, flags) \
  2397         -	(tclStubsPtr->tcl_SetVar)(interp, varName, newValue, flags) /* 237 */
         2396  +#define Tcl_SetVar \
         2397  +	(tclStubsPtr->tcl_SetVar) /* 237 */
  2398   2398   #endif
  2399   2399   #ifndef Tcl_SetVar2
  2400         -#define Tcl_SetVar2(interp, part1, part2, newValue, flags) \
  2401         -	(tclStubsPtr->tcl_SetVar2)(interp, part1, part2, newValue, flags) /* 238 */
         2400  +#define Tcl_SetVar2 \
         2401  +	(tclStubsPtr->tcl_SetVar2) /* 238 */
  2402   2402   #endif
  2403   2403   #ifndef Tcl_SignalId
  2404         -#define Tcl_SignalId(sig) \
  2405         -	(tclStubsPtr->tcl_SignalId)(sig) /* 239 */
         2404  +#define Tcl_SignalId \
         2405  +	(tclStubsPtr->tcl_SignalId) /* 239 */
  2406   2406   #endif
  2407   2407   #ifndef Tcl_SignalMsg
  2408         -#define Tcl_SignalMsg(sig) \
  2409         -	(tclStubsPtr->tcl_SignalMsg)(sig) /* 240 */
         2408  +#define Tcl_SignalMsg \
         2409  +	(tclStubsPtr->tcl_SignalMsg) /* 240 */
  2410   2410   #endif
  2411   2411   #ifndef Tcl_SourceRCFile
  2412         -#define Tcl_SourceRCFile(interp) \
  2413         -	(tclStubsPtr->tcl_SourceRCFile)(interp) /* 241 */
         2412  +#define Tcl_SourceRCFile \
         2413  +	(tclStubsPtr->tcl_SourceRCFile) /* 241 */
  2414   2414   #endif
  2415   2415   #ifndef Tcl_SplitList
  2416         -#define Tcl_SplitList(interp, listStr, argcPtr, argvPtr) \
  2417         -	(tclStubsPtr->tcl_SplitList)(interp, listStr, argcPtr, argvPtr) /* 242 */
         2416  +#define Tcl_SplitList \
         2417  +	(tclStubsPtr->tcl_SplitList) /* 242 */
  2418   2418   #endif
  2419   2419   #ifndef Tcl_SplitPath
  2420         -#define Tcl_SplitPath(path, argcPtr, argvPtr) \
  2421         -	(tclStubsPtr->tcl_SplitPath)(path, argcPtr, argvPtr) /* 243 */
         2420  +#define Tcl_SplitPath \
         2421  +	(tclStubsPtr->tcl_SplitPath) /* 243 */
  2422   2422   #endif
  2423   2423   #ifndef Tcl_StaticPackage
  2424         -#define Tcl_StaticPackage(interp, pkgName, initProc, safeInitProc) \
  2425         -	(tclStubsPtr->tcl_StaticPackage)(interp, pkgName, initProc, safeInitProc) /* 244 */
         2424  +#define Tcl_StaticPackage \
         2425  +	(tclStubsPtr->tcl_StaticPackage) /* 244 */
  2426   2426   #endif
  2427   2427   #ifndef Tcl_StringMatch
  2428         -#define Tcl_StringMatch(str, pattern) \
  2429         -	(tclStubsPtr->tcl_StringMatch)(str, pattern) /* 245 */
         2428  +#define Tcl_StringMatch \
         2429  +	(tclStubsPtr->tcl_StringMatch) /* 245 */
  2430   2430   #endif
  2431   2431   #ifndef Tcl_Tell
  2432         -#define Tcl_Tell(chan) \
  2433         -	(tclStubsPtr->tcl_Tell)(chan) /* 246 */
         2432  +#define Tcl_Tell \
         2433  +	(tclStubsPtr->tcl_Tell) /* 246 */
  2434   2434   #endif
  2435   2435   #ifndef Tcl_TraceVar
  2436         -#define Tcl_TraceVar(interp, varName, flags, proc, clientData) \
  2437         -	(tclStubsPtr->tcl_TraceVar)(interp, varName, flags, proc, clientData) /* 247 */
         2436  +#define Tcl_TraceVar \
         2437  +	(tclStubsPtr->tcl_TraceVar) /* 247 */
  2438   2438   #endif
  2439   2439   #ifndef Tcl_TraceVar2
  2440         -#define Tcl_TraceVar2(interp, part1, part2, flags, proc, clientData) \
  2441         -	(tclStubsPtr->tcl_TraceVar2)(interp, part1, part2, flags, proc, clientData) /* 248 */
         2440  +#define Tcl_TraceVar2 \
         2441  +	(tclStubsPtr->tcl_TraceVar2) /* 248 */
  2442   2442   #endif
  2443   2443   #ifndef Tcl_TranslateFileName
  2444         -#define Tcl_TranslateFileName(interp, name, bufferPtr) \
  2445         -	(tclStubsPtr->tcl_TranslateFileName)(interp, name, bufferPtr) /* 249 */
         2444  +#define Tcl_TranslateFileName \
         2445  +	(tclStubsPtr->tcl_TranslateFileName) /* 249 */
  2446   2446   #endif
  2447   2447   #ifndef Tcl_Ungets
  2448         -#define Tcl_Ungets(chan, str, len, atHead) \
  2449         -	(tclStubsPtr->tcl_Ungets)(chan, str, len, atHead) /* 250 */
         2448  +#define Tcl_Ungets \
         2449  +	(tclStubsPtr->tcl_Ungets) /* 250 */
  2450   2450   #endif
  2451   2451   #ifndef Tcl_UnlinkVar
  2452         -#define Tcl_UnlinkVar(interp, varName) \
  2453         -	(tclStubsPtr->tcl_UnlinkVar)(interp, varName) /* 251 */
         2452  +#define Tcl_UnlinkVar \
         2453  +	(tclStubsPtr->tcl_UnlinkVar) /* 251 */
  2454   2454   #endif
  2455   2455   #ifndef Tcl_UnregisterChannel
  2456         -#define Tcl_UnregisterChannel(interp, chan) \
  2457         -	(tclStubsPtr->tcl_UnregisterChannel)(interp, chan) /* 252 */
         2456  +#define Tcl_UnregisterChannel \
         2457  +	(tclStubsPtr->tcl_UnregisterChannel) /* 252 */
  2458   2458   #endif
  2459   2459   #ifndef Tcl_UnsetVar
  2460         -#define Tcl_UnsetVar(interp, varName, flags) \
  2461         -	(tclStubsPtr->tcl_UnsetVar)(interp, varName, flags) /* 253 */
         2460  +#define Tcl_UnsetVar \
         2461  +	(tclStubsPtr->tcl_UnsetVar) /* 253 */
  2462   2462   #endif
  2463   2463   #ifndef Tcl_UnsetVar2
  2464         -#define Tcl_UnsetVar2(interp, part1, part2, flags) \
  2465         -	(tclStubsPtr->tcl_UnsetVar2)(interp, part1, part2, flags) /* 254 */
         2464  +#define Tcl_UnsetVar2 \
         2465  +	(tclStubsPtr->tcl_UnsetVar2) /* 254 */
  2466   2466   #endif
  2467   2467   #ifndef Tcl_UntraceVar
  2468         -#define Tcl_UntraceVar(interp, varName, flags, proc, clientData) \
  2469         -	(tclStubsPtr->tcl_UntraceVar)(interp, varName, flags, proc, clientData) /* 255 */
         2468  +#define Tcl_UntraceVar \
         2469  +	(tclStubsPtr->tcl_UntraceVar) /* 255 */
  2470   2470   #endif
  2471   2471   #ifndef Tcl_UntraceVar2
  2472         -#define Tcl_UntraceVar2(interp, part1, part2, flags, proc, clientData) \
  2473         -	(tclStubsPtr->tcl_UntraceVar2)(interp, part1, part2, flags, proc, clientData) /* 256 */
         2472  +#define Tcl_UntraceVar2 \
         2473  +	(tclStubsPtr->tcl_UntraceVar2) /* 256 */
  2474   2474   #endif
  2475   2475   #ifndef Tcl_UpdateLinkedVar
  2476         -#define Tcl_UpdateLinkedVar(interp, varName) \
  2477         -	(tclStubsPtr->tcl_UpdateLinkedVar)(interp, varName) /* 257 */
         2476  +#define Tcl_UpdateLinkedVar \
         2477  +	(tclStubsPtr->tcl_UpdateLinkedVar) /* 257 */
  2478   2478   #endif
  2479   2479   #ifndef Tcl_UpVar
  2480         -#define Tcl_UpVar(interp, frameName, varName, localName, flags) \
  2481         -	(tclStubsPtr->tcl_UpVar)(interp, frameName, varName, localName, flags) /* 258 */
         2480  +#define Tcl_UpVar \
         2481  +	(tclStubsPtr->tcl_UpVar) /* 258 */
  2482   2482   #endif
  2483   2483   #ifndef Tcl_UpVar2
  2484         -#define Tcl_UpVar2(interp, frameName, part1, part2, localName, flags) \
  2485         -	(tclStubsPtr->tcl_UpVar2)(interp, frameName, part1, part2, localName, flags) /* 259 */
         2484  +#define Tcl_UpVar2 \
         2485  +	(tclStubsPtr->tcl_UpVar2) /* 259 */
  2486   2486   #endif
  2487   2487   #ifndef Tcl_VarEval
  2488   2488   #define Tcl_VarEval \
  2489   2489   	(tclStubsPtr->tcl_VarEval) /* 260 */
  2490   2490   #endif
  2491   2491   #ifndef Tcl_VarTraceInfo
  2492         -#define Tcl_VarTraceInfo(interp, varName, flags, procPtr, prevClientData) \
  2493         -	(tclStubsPtr->tcl_VarTraceInfo)(interp, varName, flags, procPtr, prevClientData) /* 261 */
         2492  +#define Tcl_VarTraceInfo \
         2493  +	(tclStubsPtr->tcl_VarTraceInfo) /* 261 */
  2494   2494   #endif
  2495   2495   #ifndef Tcl_VarTraceInfo2
  2496         -#define Tcl_VarTraceInfo2(interp, part1, part2, flags, procPtr, prevClientData) \
  2497         -	(tclStubsPtr->tcl_VarTraceInfo2)(interp, part1, part2, flags, procPtr, prevClientData) /* 262 */
         2496  +#define Tcl_VarTraceInfo2 \
         2497  +	(tclStubsPtr->tcl_VarTraceInfo2) /* 262 */
  2498   2498   #endif
  2499   2499   #ifndef Tcl_Write
  2500         -#define Tcl_Write(chan, s, slen) \
  2501         -	(tclStubsPtr->tcl_Write)(chan, s, slen) /* 263 */
         2500  +#define Tcl_Write \
         2501  +	(tclStubsPtr->tcl_Write) /* 263 */
  2502   2502   #endif
  2503   2503   #ifndef Tcl_WrongNumArgs
  2504         -#define Tcl_WrongNumArgs(interp, objc, objv, message) \
  2505         -	(tclStubsPtr->tcl_WrongNumArgs)(interp, objc, objv, message) /* 264 */
         2504  +#define Tcl_WrongNumArgs \
         2505  +	(tclStubsPtr->tcl_WrongNumArgs) /* 264 */
  2506   2506   #endif
  2507   2507   #ifndef Tcl_DumpActiveMemory
  2508         -#define Tcl_DumpActiveMemory(fileName) \
  2509         -	(tclStubsPtr->tcl_DumpActiveMemory)(fileName) /* 265 */
         2508  +#define Tcl_DumpActiveMemory \
         2509  +	(tclStubsPtr->tcl_DumpActiveMemory) /* 265 */
  2510   2510   #endif
  2511   2511   #ifndef Tcl_ValidateAllMemory
  2512         -#define Tcl_ValidateAllMemory(file, line) \
  2513         -	(tclStubsPtr->tcl_ValidateAllMemory)(file, line) /* 266 */
         2512  +#define Tcl_ValidateAllMemory \
         2513  +	(tclStubsPtr->tcl_ValidateAllMemory) /* 266 */
  2514   2514   #endif
  2515   2515   #ifndef Tcl_AppendResultVA
  2516         -#define Tcl_AppendResultVA(interp, argList) \
  2517         -	(tclStubsPtr->tcl_AppendResultVA)(interp, argList) /* 267 */
         2516  +#define Tcl_AppendResultVA \
         2517  +	(tclStubsPtr->tcl_AppendResultVA) /* 267 */
  2518   2518   #endif
  2519   2519   #ifndef Tcl_AppendStringsToObjVA
  2520         -#define Tcl_AppendStringsToObjVA(objPtr, argList) \
  2521         -	(tclStubsPtr->tcl_AppendStringsToObjVA)(objPtr, argList) /* 268 */
         2520  +#define Tcl_AppendStringsToObjVA \
         2521  +	(tclStubsPtr->tcl_AppendStringsToObjVA) /* 268 */
  2522   2522   #endif
  2523   2523   #ifndef Tcl_HashStats
  2524         -#define Tcl_HashStats(tablePtr) \
  2525         -	(tclStubsPtr->tcl_HashStats)(tablePtr) /* 269 */
         2524  +#define Tcl_HashStats \
         2525  +	(tclStubsPtr->tcl_HashStats) /* 269 */
  2526   2526   #endif
  2527   2527   #ifndef Tcl_ParseVar
  2528         -#define Tcl_ParseVar(interp, str, termPtr) \
  2529         -	(tclStubsPtr->tcl_ParseVar)(interp, str, termPtr) /* 270 */
         2528  +#define Tcl_ParseVar \
         2529  +	(tclStubsPtr->tcl_ParseVar) /* 270 */
  2530   2530   #endif
  2531   2531   #ifndef Tcl_PkgPresent
  2532         -#define Tcl_PkgPresent(interp, name, version, exact) \
  2533         -	(tclStubsPtr->tcl_PkgPresent)(interp, name, version, exact) /* 271 */
         2532  +#define Tcl_PkgPresent \
         2533  +	(tclStubsPtr->tcl_PkgPresent) /* 271 */
  2534   2534   #endif
  2535   2535   #ifndef Tcl_PkgPresentEx
  2536         -#define Tcl_PkgPresentEx(interp, name, version, exact, clientDataPtr) \
  2537         -	(tclStubsPtr->tcl_PkgPresentEx)(interp, name, version, exact, clientDataPtr) /* 272 */
         2536  +#define Tcl_PkgPresentEx \
         2537  +	(tclStubsPtr->tcl_PkgPresentEx) /* 272 */
  2538   2538   #endif
  2539   2539   #ifndef Tcl_PkgProvide
  2540         -#define Tcl_PkgProvide(interp, name, version) \
  2541         -	(tclStubsPtr->tcl_PkgProvide)(interp, name, version) /* 273 */
         2540  +#define Tcl_PkgProvide \
         2541  +	(tclStubsPtr->tcl_PkgProvide) /* 273 */
  2542   2542   #endif
  2543   2543   #ifndef Tcl_PkgRequire
  2544         -#define Tcl_PkgRequire(interp, name, version, exact) \
  2545         -	(tclStubsPtr->tcl_PkgRequire)(interp, name, version, exact) /* 274 */
         2544  +#define Tcl_PkgRequire \
         2545  +	(tclStubsPtr->tcl_PkgRequire) /* 274 */
  2546   2546   #endif
  2547   2547   #ifndef Tcl_SetErrorCodeVA
  2548         -#define Tcl_SetErrorCodeVA(interp, argList) \
  2549         -	(tclStubsPtr->tcl_SetErrorCodeVA)(interp, argList) /* 275 */
         2548  +#define Tcl_SetErrorCodeVA \
         2549  +	(tclStubsPtr->tcl_SetErrorCodeVA) /* 275 */
  2550   2550   #endif
  2551   2551   #ifndef Tcl_VarEvalVA
  2552         -#define Tcl_VarEvalVA(interp, argList) \
  2553         -	(tclStubsPtr->tcl_VarEvalVA)(interp, argList) /* 276 */
         2552  +#define Tcl_VarEvalVA \
         2553  +	(tclStubsPtr->tcl_VarEvalVA) /* 276 */
  2554   2554   #endif
  2555   2555   #ifndef Tcl_WaitPid
  2556         -#define Tcl_WaitPid(pid, statPtr, options) \
  2557         -	(tclStubsPtr->tcl_WaitPid)(pid, statPtr, options) /* 277 */
         2556  +#define Tcl_WaitPid \
         2557  +	(tclStubsPtr->tcl_WaitPid) /* 277 */
  2558   2558   #endif
  2559   2559   #ifndef Tcl_PanicVA
  2560         -#define Tcl_PanicVA(format, argList) \
  2561         -	(tclStubsPtr->tcl_PanicVA)(format, argList) /* 278 */
         2560  +#define Tcl_PanicVA \
         2561  +	(tclStubsPtr->tcl_PanicVA) /* 278 */
  2562   2562   #endif
  2563   2563   #ifndef Tcl_GetVersion
  2564         -#define Tcl_GetVersion(major, minor, patchLevel, type) \
  2565         -	(tclStubsPtr->tcl_GetVersion)(major, minor, patchLevel, type) /* 279 */
         2564  +#define Tcl_GetVersion \
         2565  +	(tclStubsPtr->tcl_GetVersion) /* 279 */
  2566   2566   #endif
  2567   2567   /* Slot 280 is reserved */
  2568   2568   /* Slot 281 is reserved */
  2569   2569   /* Slot 282 is reserved */
  2570   2570   /* Slot 283 is reserved */
  2571   2571   /* Slot 284 is reserved */
  2572   2572   /* Slot 285 is reserved */
  2573   2573   #ifndef Tcl_AppendObjToObj
  2574         -#define Tcl_AppendObjToObj(objPtr, appendObjPtr) \
  2575         -	(tclStubsPtr->tcl_AppendObjToObj)(objPtr, appendObjPtr) /* 286 */
         2574  +#define Tcl_AppendObjToObj \
         2575  +	(tclStubsPtr->tcl_AppendObjToObj) /* 286 */
  2576   2576   #endif
  2577   2577   #ifndef Tcl_CreateEncoding
  2578         -#define Tcl_CreateEncoding(typePtr) \
  2579         -	(tclStubsPtr->tcl_CreateEncoding)(typePtr) /* 287 */
         2578  +#define Tcl_CreateEncoding \
         2579  +	(tclStubsPtr->tcl_CreateEncoding) /* 287 */
  2580   2580   #endif
  2581   2581   #ifndef Tcl_CreateThreadExitHandler
  2582         -#define Tcl_CreateThreadExitHandler(proc, clientData) \
  2583         -	(tclStubsPtr->tcl_CreateThreadExitHandler)(proc, clientData) /* 288 */
         2582  +#define Tcl_CreateThreadExitHandler \
         2583  +	(tclStubsPtr->tcl_CreateThreadExitHandler) /* 288 */
  2584   2584   #endif
  2585   2585   #ifndef Tcl_DeleteThreadExitHandler
  2586         -#define Tcl_DeleteThreadExitHandler(proc, clientData) \
  2587         -	(tclStubsPtr->tcl_DeleteThreadExitHandler)(proc, clientData) /* 289 */
         2586  +#define Tcl_DeleteThreadExitHandler \
         2587  +	(tclStubsPtr->tcl_DeleteThreadExitHandler) /* 289 */
  2588   2588   #endif
  2589   2589   #ifndef Tcl_DiscardResult
  2590         -#define Tcl_DiscardResult(statePtr) \
  2591         -	(tclStubsPtr->tcl_DiscardResult)(statePtr) /* 290 */
         2590  +#define Tcl_DiscardResult \
         2591  +	(tclStubsPtr->tcl_DiscardResult) /* 290 */
  2592   2592   #endif
  2593   2593   #ifndef Tcl_EvalEx
  2594         -#define Tcl_EvalEx(interp, script, numBytes, flags) \
  2595         -	(tclStubsPtr->tcl_EvalEx)(interp, script, numBytes, flags) /* 291 */
         2594  +#define Tcl_EvalEx \
         2595  +	(tclStubsPtr->tcl_EvalEx) /* 291 */
  2596   2596   #endif
  2597   2597   #ifndef Tcl_EvalObjv
  2598         -#define Tcl_EvalObjv(interp, objc, objv, flags) \
  2599         -	(tclStubsPtr->tcl_EvalObjv)(interp, objc, objv, flags) /* 292 */
         2598  +#define Tcl_EvalObjv \
         2599  +	(tclStubsPtr->tcl_EvalObjv) /* 292 */
  2600   2600   #endif
  2601   2601   #ifndef Tcl_EvalObjEx
  2602         -#define Tcl_EvalObjEx(interp, objPtr, flags) \
  2603         -	(tclStubsPtr->tcl_EvalObjEx)(interp, objPtr, flags) /* 293 */
         2602  +#define Tcl_EvalObjEx \
         2603  +	(tclStubsPtr->tcl_EvalObjEx) /* 293 */
  2604   2604   #endif
  2605   2605   #ifndef Tcl_ExitThread
  2606         -#define Tcl_ExitThread(status) \
  2607         -	(tclStubsPtr->tcl_ExitThread)(status) /* 294 */
         2606  +#define Tcl_ExitThread \
         2607  +	(tclStubsPtr->tcl_ExitThread) /* 294 */
  2608   2608   #endif
  2609   2609   #ifndef Tcl_ExternalToUtf
  2610         -#define Tcl_ExternalToUtf(interp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr) \
  2611         -	(tclStubsPtr->tcl_ExternalToUtf)(interp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr) /* 295 */
         2610  +#define Tcl_ExternalToUtf \
         2611  +	(tclStubsPtr->tcl_ExternalToUtf) /* 295 */
  2612   2612   #endif
  2613   2613   #ifndef Tcl_ExternalToUtfDString
  2614         -#define Tcl_ExternalToUtfDString(encoding, src, srcLen, dsPtr) \
  2615         -	(tclStubsPtr->tcl_ExternalToUtfDString)(encoding, src, srcLen, dsPtr) /* 296 */
         2614  +#define Tcl_ExternalToUtfDString \
         2615  +	(tclStubsPtr->tcl_ExternalToUtfDString) /* 296 */
  2616   2616   #endif
  2617   2617   #ifndef Tcl_FinalizeThread
  2618         -#define Tcl_FinalizeThread() \
  2619         -	(tclStubsPtr->tcl_FinalizeThread)() /* 297 */
         2618  +#define Tcl_FinalizeThread \
         2619  +	(tclStubsPtr->tcl_FinalizeThread) /* 297 */
  2620   2620   #endif
  2621   2621   #ifndef Tcl_FinalizeNotifier
  2622         -#define Tcl_FinalizeNotifier(clientData) \
  2623         -	(tclStubsPtr->tcl_FinalizeNotifier)(clientData) /* 298 */
         2622  +#define Tcl_FinalizeNotifier \
         2623  +	(tclStubsPtr->tcl_FinalizeNotifier) /* 298 */
  2624   2624   #endif
  2625   2625   #ifndef Tcl_FreeEncoding
  2626         -#define Tcl_FreeEncoding(encoding) \
  2627         -	(tclStubsPtr->tcl_FreeEncoding)(encoding) /* 299 */
         2626  +#define Tcl_FreeEncoding \
         2627  +	(tclStubsPtr->tcl_FreeEncoding) /* 299 */
  2628   2628   #endif
  2629   2629   #ifndef Tcl_GetCurrentThread
  2630         -#define Tcl_GetCurrentThread() \
  2631         -	(tclStubsPtr->tcl_GetCurrentThread)() /* 300 */
         2630  +#define Tcl_GetCurrentThread \
         2631  +	(tclStubsPtr->tcl_GetCurrentThread) /* 300 */
  2632   2632   #endif
  2633   2633   #ifndef Tcl_GetEncoding
  2634         -#define Tcl_GetEncoding(interp, name) \
  2635         -	(tclStubsPtr->tcl_GetEncoding)(interp, name) /* 301 */
         2634  +#define Tcl_GetEncoding \
         2635  +	(tclStubsPtr->tcl_GetEncoding) /* 301 */
  2636   2636   #endif
  2637   2637   #ifndef Tcl_GetEncodingName
  2638         -#define Tcl_GetEncodingName(encoding) \
  2639         -	(tclStubsPtr->tcl_GetEncodingName)(encoding) /* 302 */
         2638  +#define Tcl_GetEncodingName \
         2639  +	(tclStubsPtr->tcl_GetEncodingName) /* 302 */
  2640   2640   #endif
  2641   2641   #ifndef Tcl_GetEncodingNames
  2642         -#define Tcl_GetEncodingNames(interp) \
  2643         -	(tclStubsPtr->tcl_GetEncodingNames)(interp) /* 303 */
         2642  +#define Tcl_GetEncodingNames \
         2643  +	(tclStubsPtr->tcl_GetEncodingNames) /* 303 */
  2644   2644   #endif
  2645   2645   #ifndef Tcl_GetIndexFromObjStruct
  2646         -#define Tcl_GetIndexFromObjStruct(interp, objPtr, tablePtr, offset, msg, flags, indexPtr) \
  2647         -	(tclStubsPtr->tcl_GetIndexFromObjStruct)(interp, objPtr, tablePtr, offset, msg, flags, indexPtr) /* 304 */
         2646  +#define Tcl_GetIndexFromObjStruct \
         2647  +	(tclStubsPtr->tcl_GetIndexFromObjStruct) /* 304 */
  2648   2648   #endif
  2649   2649   #ifndef Tcl_GetThreadData
  2650         -#define Tcl_GetThreadData(keyPtr, size) \
  2651         -	(tclStubsPtr->tcl_GetThreadData)(keyPtr, size) /* 305 */
         2650  +#define Tcl_GetThreadData \
         2651  +	(tclStubsPtr->tcl_GetThreadData) /* 305 */
  2652   2652   #endif
  2653   2653   #ifndef Tcl_GetVar2Ex
  2654         -#define Tcl_GetVar2Ex(interp, part1, part2, flags) \
  2655         -	(tclStubsPtr->tcl_GetVar2Ex)(interp, part1, part2, flags) /* 306 */
         2654  +#define Tcl_GetVar2Ex \
         2655  +	(tclStubsPtr->tcl_GetVar2Ex) /* 306 */
  2656   2656   #endif
  2657   2657   #ifndef Tcl_InitNotifier
  2658         -#define Tcl_InitNotifier() \
  2659         -	(tclStubsPtr->tcl_InitNotifier)() /* 307 */
         2658  +#define Tcl_InitNotifier \
         2659  +	(tclStubsPtr->tcl_InitNotifier) /* 307 */
  2660   2660   #endif
  2661   2661   #ifndef Tcl_MutexLock
  2662         -#define Tcl_MutexLock(mutexPtr) \
  2663         -	(tclStubsPtr->tcl_MutexLock)(mutexPtr) /* 308 */
         2662  +#define Tcl_MutexLock \
         2663  +	(tclStubsPtr->tcl_MutexLock) /* 308 */
  2664   2664   #endif
  2665   2665   #ifndef Tcl_MutexUnlock
  2666         -#define Tcl_MutexUnlock(mutexPtr) \
  2667         -	(tclStubsPtr->tcl_MutexUnlock)(mutexPtr) /* 309 */
         2666  +#define Tcl_MutexUnlock \
         2667  +	(tclStubsPtr->tcl_MutexUnlock) /* 309 */
  2668   2668   #endif
  2669   2669   #ifndef Tcl_ConditionNotify
  2670         -#define Tcl_ConditionNotify(condPtr) \
  2671         -	(tclStubsPtr->tcl_ConditionNotify)(condPtr) /* 310 */
         2670  +#define Tcl_ConditionNotify \
         2671  +	(tclStubsPtr->tcl_ConditionNotify) /* 310 */
  2672   2672   #endif
  2673   2673   #ifndef Tcl_ConditionWait
  2674         -#define Tcl_ConditionWait(condPtr, mutexPtr, timePtr) \
  2675         -	(tclStubsPtr->tcl_ConditionWait)(condPtr, mutexPtr, timePtr) /* 311 */
         2674  +#define Tcl_ConditionWait \
         2675  +	(tclStubsPtr->tcl_ConditionWait) /* 311 */
  2676   2676   #endif
  2677   2677   #ifndef Tcl_NumUtfChars
  2678         -#define Tcl_NumUtfChars(src, len) \
  2679         -	(tclStubsPtr->tcl_NumUtfChars)(src, len) /* 312 */
         2678  +#define Tcl_NumUtfChars \
         2679  +	(tclStubsPtr->tcl_NumUtfChars) /* 312 */
  2680   2680   #endif
  2681   2681   #ifndef Tcl_ReadChars
  2682         -#define Tcl_ReadChars(channel, objPtr, charsToRead, appendFlag) \
  2683         -	(tclStubsPtr->tcl_ReadChars)(channel, objPtr, charsToRead, appendFlag) /* 313 */
         2682  +#define Tcl_ReadChars \
         2683  +	(tclStubsPtr->tcl_ReadChars) /* 313 */
  2684   2684   #endif
  2685   2685   #ifndef Tcl_RestoreResult
  2686         -#define Tcl_RestoreResult(interp, statePtr) \
  2687         -	(tclStubsPtr->tcl_RestoreResult)(interp, statePtr) /* 314 */
         2686  +#define Tcl_RestoreResult \
         2687  +	(tclStubsPtr->tcl_RestoreResult) /* 314 */
  2688   2688   #endif
  2689   2689   #ifndef Tcl_SaveResult
  2690         -#define Tcl_SaveResult(interp, statePtr) \
  2691         -	(tclStubsPtr->tcl_SaveResult)(interp, statePtr) /* 315 */
         2690  +#define Tcl_SaveResult \
         2691  +	(tclStubsPtr->tcl_SaveResult) /* 315 */
  2692   2692   #endif
  2693   2693   #ifndef Tcl_SetSystemEncoding
  2694         -#define Tcl_SetSystemEncoding(interp, name) \
  2695         -	(tclStubsPtr->tcl_SetSystemEncoding)(interp, name) /* 316 */
         2694  +#define Tcl_SetSystemEncoding \
         2695  +	(tclStubsPtr->tcl_SetSystemEncoding) /* 316 */
  2696   2696   #endif
  2697   2697   #ifndef Tcl_SetVar2Ex
  2698         -#define Tcl_SetVar2Ex(interp, part1, part2, newValuePtr, flags) \
  2699         -	(tclStubsPtr->tcl_SetVar2Ex)(interp, part1, part2, newValuePtr, flags) /* 317 */
         2698  +#define Tcl_SetVar2Ex \
         2699  +	(tclStubsPtr->tcl_SetVar2Ex) /* 317 */
  2700   2700   #endif
  2701   2701   #ifndef Tcl_ThreadAlert
  2702         -#define Tcl_ThreadAlert(threadId) \
  2703         -	(tclStubsPtr->tcl_ThreadAlert)(threadId) /* 318 */
         2702  +#define Tcl_ThreadAlert \
         2703  +	(tclStubsPtr->tcl_ThreadAlert) /* 318 */
  2704   2704   #endif
  2705   2705   #ifndef Tcl_ThreadQueueEvent
  2706         -#define Tcl_ThreadQueueEvent(threadId, evPtr, position) \
  2707         -	(tclStubsPtr->tcl_ThreadQueueEvent)(threadId, evPtr, position) /* 319 */
         2706  +#define Tcl_ThreadQueueEvent \
         2707  +	(tclStubsPtr->tcl_ThreadQueueEvent) /* 319 */
  2708   2708   #endif
  2709   2709   #ifndef Tcl_UniCharAtIndex
  2710         -#define Tcl_UniCharAtIndex(src, index) \
  2711         -	(tclStubsPtr->tcl_UniCharAtIndex)(src, index) /* 320 */
         2710  +#define Tcl_UniCharAtIndex \
         2711  +	(tclStubsPtr->tcl_UniCharAtIndex) /* 320 */
  2712   2712   #endif
  2713   2713   #ifndef Tcl_UniCharToLower
  2714         -#define Tcl_UniCharToLower(ch) \
  2715         -	(tclStubsPtr->tcl_UniCharToLower)(ch) /* 321 */
         2714  +#define Tcl_UniCharToLower \
         2715  +	(tclStubsPtr->tcl_UniCharToLower) /* 321 */
  2716   2716   #endif
  2717   2717   #ifndef Tcl_UniCharToTitle
  2718         -#define Tcl_UniCharToTitle(ch) \
  2719         -	(tclStubsPtr->tcl_UniCharToTitle)(ch) /* 322 */
         2718  +#define Tcl_UniCharToTitle \
         2719  +	(tclStubsPtr->tcl_UniCharToTitle) /* 322 */
  2720   2720   #endif
  2721   2721   #ifndef Tcl_UniCharToUpper
  2722         -#define Tcl_UniCharToUpper(ch) \
  2723         -	(tclStubsPtr->tcl_UniCharToUpper)(ch) /* 323 */
         2722  +#define Tcl_UniCharToUpper \
         2723  +	(tclStubsPtr->tcl_UniCharToUpper) /* 323 */
  2724   2724   #endif
  2725   2725   #ifndef Tcl_UniCharToUtf
  2726         -#define Tcl_UniCharToUtf(ch, buf) \
  2727         -	(tclStubsPtr->tcl_UniCharToUtf)(ch, buf) /* 324 */
         2726  +#define Tcl_UniCharToUtf \
         2727  +	(tclStubsPtr->tcl_UniCharToUtf) /* 324 */
  2728   2728   #endif
  2729   2729   #ifndef Tcl_UtfAtIndex
  2730         -#define Tcl_UtfAtIndex(src, index) \
  2731         -	(tclStubsPtr->tcl_UtfAtIndex)(src, index) /* 325 */
         2730  +#define Tcl_UtfAtIndex \
         2731  +	(tclStubsPtr->tcl_UtfAtIndex) /* 325 */
  2732   2732   #endif
  2733   2733   #ifndef Tcl_UtfCharComplete
  2734         -#define Tcl_UtfCharComplete(src, len) \
  2735         -	(tclStubsPtr->tcl_UtfCharComplete)(src, len) /* 326 */
         2734  +#define Tcl_UtfCharComplete \
         2735  +	(tclStubsPtr->tcl_UtfCharComplete) /* 326 */
  2736   2736   #endif
  2737   2737   #ifndef Tcl_UtfBackslash
  2738         -#define Tcl_UtfBackslash(src, readPtr, dst) \
  2739         -	(tclStubsPtr->tcl_UtfBackslash)(src, readPtr, dst) /* 327 */
         2738  +#define Tcl_UtfBackslash \
         2739  +	(tclStubsPtr->tcl_UtfBackslash) /* 327 */
  2740   2740   #endif
  2741   2741   #ifndef Tcl_UtfFindFirst
  2742         -#define Tcl_UtfFindFirst(src, ch) \
  2743         -	(tclStubsPtr->tcl_UtfFindFirst)(src, ch) /* 328 */
         2742  +#define Tcl_UtfFindFirst \
         2743  +	(tclStubsPtr->tcl_UtfFindFirst) /* 328 */
  2744   2744   #endif
  2745   2745   #ifndef Tcl_UtfFindLast
  2746         -#define Tcl_UtfFindLast(src, ch) \
  2747         -	(tclStubsPtr->tcl_UtfFindLast)(src, ch) /* 329 */
         2746  +#define Tcl_UtfFindLast \
         2747  +	(tclStubsPtr->tcl_UtfFindLast) /* 329 */
  2748   2748   #endif
  2749   2749   #ifndef Tcl_UtfNext
  2750         -#define Tcl_UtfNext(src) \
  2751         -	(tclStubsPtr->tcl_UtfNext)(src) /* 330 */
         2750  +#define Tcl_UtfNext \
         2751  +	(tclStubsPtr->tcl_UtfNext) /* 330 */
  2752   2752   #endif
  2753   2753   #ifndef Tcl_UtfPrev
  2754         -#define Tcl_UtfPrev(src, start) \
  2755         -	(tclStubsPtr->tcl_UtfPrev)(src, start) /* 331 */
         2754  +#define Tcl_UtfPrev \
         2755  +	(tclStubsPtr->tcl_UtfPrev) /* 331 */
  2756   2756   #endif
  2757   2757   #ifndef Tcl_UtfToExternal
  2758         -#define Tcl_UtfToExternal(interp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr) \
  2759         -	(tclStubsPtr->tcl_UtfToExternal)(interp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr) /* 332 */
         2758  +#define Tcl_UtfToExternal \
         2759  +	(tclStubsPtr->tcl_UtfToExternal) /* 332 */
  2760   2760   #endif
  2761   2761   #ifndef Tcl_UtfToExternalDString
  2762         -#define Tcl_UtfToExternalDString(encoding, src, srcLen, dsPtr) \
  2763         -	(tclStubsPtr->tcl_UtfToExternalDString)(encoding, src, srcLen, dsPtr) /* 333 */
         2762  +#define Tcl_UtfToExternalDString \
         2763  +	(tclStubsPtr->tcl_UtfToExternalDString) /* 333 */
  2764   2764   #endif
  2765   2765   #ifndef Tcl_UtfToLower
  2766         -#define Tcl_UtfToLower(src) \
  2767         -	(tclStubsPtr->tcl_UtfToLower)(src) /* 334 */
         2766  +#define Tcl_UtfToLower \
         2767  +	(tclStubsPtr->tcl_UtfToLower) /* 334 */
  2768   2768   #endif
  2769   2769   #ifndef Tcl_UtfToTitle
  2770         -#define Tcl_UtfToTitle(src) \
  2771         -	(tclStubsPtr->tcl_UtfToTitle)(src) /* 335 */
         2770  +#define Tcl_UtfToTitle \
         2771  +	(tclStubsPtr->tcl_UtfToTitle) /* 335 */
  2772   2772   #endif
  2773   2773   #ifndef Tcl_UtfToUniChar
  2774         -#define Tcl_UtfToUniChar(src, chPtr) \
  2775         -	(tclStubsPtr->tcl_UtfToUniChar)(src, chPtr) /* 336 */
         2774  +#define Tcl_UtfToUniChar \
         2775  +	(tclStubsPtr->tcl_UtfToUniChar) /* 336 */
  2776   2776   #endif
  2777   2777   #ifndef Tcl_UtfToUpper
  2778         -#define Tcl_UtfToUpper(src) \
  2779         -	(tclStubsPtr->tcl_UtfToUpper)(src) /* 337 */
         2778  +#define Tcl_UtfToUpper \
         2779  +	(tclStubsPtr->tcl_UtfToUpper) /* 337 */
  2780   2780   #endif
  2781   2781   #ifndef Tcl_WriteChars
  2782         -#define Tcl_WriteChars(chan, src, srcLen) \
  2783         -	(tclStubsPtr->tcl_WriteChars)(chan, src, srcLen) /* 338 */
         2782  +#define Tcl_WriteChars \
         2783  +	(tclStubsPtr->tcl_WriteChars) /* 338 */
  2784   2784   #endif
  2785   2785   #ifndef Tcl_WriteObj
  2786         -#define Tcl_WriteObj(chan, objPtr) \
  2787         -	(tclStubsPtr->tcl_WriteObj)(chan, objPtr) /* 339 */
         2786  +#define Tcl_WriteObj \
         2787  +	(tclStubsPtr->tcl_WriteObj) /* 339 */
  2788   2788   #endif
  2789   2789   #ifndef Tcl_GetString
  2790         -#define Tcl_GetString(objPtr) \
  2791         -	(tclStubsPtr->tcl_GetString)(objPtr) /* 340 */
         2790  +#define Tcl_GetString \
         2791  +	(tclStubsPtr->tcl_GetString) /* 340 */
  2792   2792   #endif
  2793   2793   #ifndef Tcl_GetDefaultEncodingDir
  2794         -#define Tcl_GetDefaultEncodingDir() \
  2795         -	(tclStubsPtr->tcl_GetDefaultEncodingDir)() /* 341 */
         2794  +#define Tcl_GetDefaultEncodingDir \
         2795  +	(tclStubsPtr->tcl_GetDefaultEncodingDir) /* 341 */
  2796   2796   #endif
  2797   2797   #ifndef Tcl_SetDefaultEncodingDir
  2798         -#define Tcl_SetDefaultEncodingDir(path) \
  2799         -	(tclStubsPtr->tcl_SetDefaultEncodingDir)(path) /* 342 */
         2798  +#define Tcl_SetDefaultEncodingDir \
         2799  +	(tclStubsPtr->tcl_SetDefaultEncodingDir) /* 342 */
  2800   2800   #endif
  2801   2801   #ifndef Tcl_AlertNotifier
  2802         -#define Tcl_AlertNotifier(clientData) \
  2803         -	(tclStubsPtr->tcl_AlertNotifier)(clientData) /* 343 */
         2802  +#define Tcl_AlertNotifier \
         2803  +	(tclStubsPtr->tcl_AlertNotifier) /* 343 */
  2804   2804   #endif
  2805   2805   #ifndef Tcl_ServiceModeHook
  2806         -#define Tcl_ServiceModeHook(mode) \
  2807         -	(tclStubsPtr->tcl_ServiceModeHook)(mode) /* 344 */
         2806  +#define Tcl_ServiceModeHook \
         2807  +	(tclStubsPtr->tcl_ServiceModeHook) /* 344 */
  2808   2808   #endif
  2809   2809   
  2810   2810   #endif /* defined(USE_TCL_STUBS) && !defined(USE_TCL_STUB_PROCS) */
  2811   2811   
  2812   2812   /* !END!: Do not edit above this line. */
  2813   2813   
  2814   2814   #endif /* _TCLDECLS */
  2815   2815   

Changes to generic/tclIntDecls.h.

     7      7    *	versions.  Use at your own risk.
     8      8    *
     9      9    * Copyright (c) 1998-1999 by Scriptics Corporation.
    10     10    *
    11     11    * See the file "license.terms" for information on usage and redistribution
    12     12    * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
    13     13    *
    14         - * RCS: @(#) $Id: tclIntDecls.h,v 1.3.2.5 1999/03/19 04:01:20 stanton Exp $
           14  + * RCS: @(#) $Id: tclIntDecls.h,v 1.3.2.6 1999/03/30 01:55:52 redman Exp $
    15     15    */
    16     16   
    17     17   #ifndef _TCLINTDECLS
    18     18   #define _TCLINTDECLS
    19     19   
    20     20   /*
    21     21    * WARNING: This file is automatically generated by the tools/genStubs.tcl
................................................................................
   593    593   #if defined(USE_TCL_STUBS) && !defined(USE_TCL_STUB_PROCS)
   594    594   
   595    595   /*
   596    596    * Inline function declarations:
   597    597    */
   598    598   
   599    599   #ifndef TclAccess
   600         -#define TclAccess(path, mode) \
   601         -	(tclIntStubsPtr->tclAccess)(path, mode) /* 0 */
          600  +#define TclAccess \
          601  +	(tclIntStubsPtr->tclAccess) /* 0 */
   602    602   #endif
   603    603   #ifndef TclAccessDeleteProc
   604         -#define TclAccessDeleteProc(proc) \
   605         -	(tclIntStubsPtr->tclAccessDeleteProc)(proc) /* 1 */
          604  +#define TclAccessDeleteProc \
          605  +	(tclIntStubsPtr->tclAccessDeleteProc) /* 1 */
   606    606   #endif
   607    607   #ifndef TclAccessInsertProc
   608         -#define TclAccessInsertProc(proc) \
   609         -	(tclIntStubsPtr->tclAccessInsertProc)(proc) /* 2 */
          608  +#define TclAccessInsertProc \
          609  +	(tclIntStubsPtr->tclAccessInsertProc) /* 2 */
   610    610   #endif
   611    611   #ifndef TclAllocateFreeObjects
   612         -#define TclAllocateFreeObjects() \
   613         -	(tclIntStubsPtr->tclAllocateFreeObjects)() /* 3 */
          612  +#define TclAllocateFreeObjects \
          613  +	(tclIntStubsPtr->tclAllocateFreeObjects) /* 3 */
   614    614   #endif
   615    615   /* Slot 4 is reserved */
   616    616   #ifndef TclCleanupChildren
   617         -#define TclCleanupChildren(interp, numPids, pidPtr, errorChan) \
   618         -	(tclIntStubsPtr->tclCleanupChildren)(interp, numPids, pidPtr, errorChan) /* 5 */
          617  +#define TclCleanupChildren \
          618  +	(tclIntStubsPtr->tclCleanupChildren) /* 5 */
   619    619   #endif
   620    620   #ifndef TclCleanupCommand
   621         -#define TclCleanupCommand(cmdPtr) \
   622         -	(tclIntStubsPtr->tclCleanupCommand)(cmdPtr) /* 6 */
          621  +#define TclCleanupCommand \
          622  +	(tclIntStubsPtr->tclCleanupCommand) /* 6 */
   623    623   #endif
   624    624   #ifndef TclCopyAndCollapse
   625         -#define TclCopyAndCollapse(count, src, dst) \
   626         -	(tclIntStubsPtr->tclCopyAndCollapse)(count, src, dst) /* 7 */
          625  +#define TclCopyAndCollapse \
          626  +	(tclIntStubsPtr->tclCopyAndCollapse) /* 7 */
   627    627   #endif
   628    628   #ifndef TclCopyChannel
   629         -#define TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr) \
   630         -	(tclIntStubsPtr->tclCopyChannel)(interp, inChan, outChan, toRead, cmdPtr) /* 8 */
          629  +#define TclCopyChannel \
          630  +	(tclIntStubsPtr->tclCopyChannel) /* 8 */
   631    631   #endif
   632    632   #ifndef TclCreatePipeline
   633         -#define TclCreatePipeline(interp, argc, argv, pidArrayPtr, inPipePtr, outPipePtr, errFilePtr) \
   634         -	(tclIntStubsPtr->tclCreatePipeline)(interp, argc, argv, pidArrayPtr, inPipePtr, outPipePtr, errFilePtr) /* 9 */
          633  +#define TclCreatePipeline \
          634  +	(tclIntStubsPtr->tclCreatePipeline) /* 9 */
   635    635   #endif
   636    636   #ifndef TclCreateProc
   637         -#define TclCreateProc(interp, nsPtr, procName, argsPtr, bodyPtr, procPtrPtr) \
   638         -	(tclIntStubsPtr->tclCreateProc)(interp, nsPtr, procName, argsPtr, bodyPtr, procPtrPtr) /* 10 */
          637  +#define TclCreateProc \
          638  +	(tclIntStubsPtr->tclCreateProc) /* 10 */
   639    639   #endif
   640    640   #ifndef TclDeleteCompiledLocalVars
   641         -#define TclDeleteCompiledLocalVars(iPtr, framePtr) \
   642         -	(tclIntStubsPtr->tclDeleteCompiledLocalVars)(iPtr, framePtr) /* 11 */
          641  +#define TclDeleteCompiledLocalVars \
          642  +	(tclIntStubsPtr->tclDeleteCompiledLocalVars) /* 11 */
   643    643   #endif
   644    644   #ifndef TclDeleteVars
   645         -#define TclDeleteVars(iPtr, tablePtr) \
   646         -	(tclIntStubsPtr->tclDeleteVars)(iPtr, tablePtr) /* 12 */
          645  +#define TclDeleteVars \
          646  +	(tclIntStubsPtr->tclDeleteVars) /* 12 */
   647    647   #endif
   648    648   #ifndef TclDoGlob
   649         -#define TclDoGlob(interp, separators, headPtr, tail) \
   650         -	(tclIntStubsPtr->tclDoGlob)(interp, separators, headPtr, tail) /* 13 */
          649  +#define TclDoGlob \
          650  +	(tclIntStubsPtr->tclDoGlob) /* 13 */
   651    651   #endif
   652    652   #ifndef TclDumpMemoryInfo
   653         -#define TclDumpMemoryInfo(outFile) \
   654         -	(tclIntStubsPtr->tclDumpMemoryInfo)(outFile) /* 14 */
          653  +#define TclDumpMemoryInfo \
          654  +	(tclIntStubsPtr->tclDumpMemoryInfo) /* 14 */
   655    655   #endif
   656    656   /* Slot 15 is reserved */
   657    657   #ifndef TclExprFloatError
   658         -#define TclExprFloatError(interp, value) \
   659         -	(tclIntStubsPtr->tclExprFloatError)(interp, value) /* 16 */
          658  +#define TclExprFloatError \
          659  +	(tclIntStubsPtr->tclExprFloatError) /* 16 */
   660    660   #endif
   661    661   #ifndef TclFileAttrsCmd
   662         -#define TclFileAttrsCmd(interp, objc, objv) \
   663         -	(tclIntStubsPtr->tclFileAttrsCmd)(interp, objc, objv) /* 17 */
          662  +#define TclFileAttrsCmd \
          663  +	(tclIntStubsPtr->tclFileAttrsCmd) /* 17 */
   664    664   #endif
   665    665   #ifndef TclFileCopyCmd
   666         -#define TclFileCopyCmd(interp, argc, argv) \
   667         -	(tclIntStubsPtr->tclFileCopyCmd)(interp, argc, argv) /* 18 */
          666  +#define TclFileCopyCmd \
          667  +	(tclIntStubsPtr->tclFileCopyCmd) /* 18 */
   668    668   #endif
   669    669   #ifndef TclFileDeleteCmd
   670         -#define TclFileDeleteCmd(interp, argc, argv) \
   671         -	(tclIntStubsPtr->tclFileDeleteCmd)(interp, argc, argv) /* 19 */
          670  +#define TclFileDeleteCmd \
          671  +	(tclIntStubsPtr->tclFileDeleteCmd) /* 19 */
   672    672   #endif
   673    673   #ifndef TclFileMakeDirsCmd
   674         -#define TclFileMakeDirsCmd(interp, argc, argv) \
   675         -	(tclIntStubsPtr->tclFileMakeDirsCmd)(interp, argc, argv) /* 20 */
          674  +#define TclFileMakeDirsCmd \
          675  +	(tclIntStubsPtr->tclFileMakeDirsCmd) /* 20 */
   676    676   #endif
   677    677   #ifndef TclFileRenameCmd
   678         -#define TclFileRenameCmd(interp, argc, argv) \
   679         -	(tclIntStubsPtr->tclFileRenameCmd)(interp, argc, argv) /* 21 */
          678  +#define TclFileRenameCmd \
          679  +	(tclIntStubsPtr->tclFileRenameCmd) /* 21 */
   680    680   #endif
   681    681   #ifndef TclFindElement
   682         -#define TclFindElement(interp, listStr, listLength, elementPtr, nextPtr, sizePtr, bracePtr) \
   683         -	(tclIntStubsPtr->tclFindElement)(interp, listStr, listLength, elementPtr, nextPtr, sizePtr, bracePtr) /* 22 */
          682  +#define TclFindElement \
          683  +	(tclIntStubsPtr->tclFindElement) /* 22 */
   684    684   #endif
   685    685   #ifndef TclFindProc
   686         -#define TclFindProc(iPtr, procName) \
   687         -	(tclIntStubsPtr->tclFindProc)(iPtr, procName) /* 23 */
          686  +#define TclFindProc \
          687  +	(tclIntStubsPtr->tclFindProc) /* 23 */
   688    688   #endif
   689    689   #ifndef TclFormatInt
   690         -#define TclFormatInt(buffer, n) \
   691         -	(tclIntStubsPtr->tclFormatInt)(buffer, n) /* 24 */
          690  +#define TclFormatInt \
          691  +	(tclIntStubsPtr->tclFormatInt) /* 24 */
   692    692   #endif
   693    693   #ifndef TclFreePackageInfo
   694         -#define TclFreePackageInfo(iPtr) \
   695         -	(tclIntStubsPtr->tclFreePackageInfo)(iPtr) /* 25 */
          694  +#define TclFreePackageInfo \
          695  +	(tclIntStubsPtr->tclFreePackageInfo) /* 25 */
   696    696   #endif
   697    697   /* Slot 26 is reserved */
   698    698   #ifndef TclGetDate
   699         -#define TclGetDate(p, now, zone, timePtr) \
   700         -	(tclIntStubsPtr->tclGetDate)(p, now, zone, timePtr) /* 27 */
          699  +#define TclGetDate \
          700  +	(tclIntStubsPtr->tclGetDate) /* 27 */
   701    701   #endif
   702    702   #ifndef TclpGetDefaultStdChannel
   703         -#define TclpGetDefaultStdChannel(type) \
   704         -	(tclIntStubsPtr->tclpGetDefaultStdChannel)(type) /* 28 */
          703  +#define TclpGetDefaultStdChannel \
          704  +	(tclIntStubsPtr->tclpGetDefaultStdChannel) /* 28 */
   705    705   #endif
   706    706   #ifndef TclGetElementOfIndexedArray
   707         -#define TclGetElementOfIndexedArray(interp, localIndex, elemPtr, leaveErrorMsg) \
   708         -	(tclIntStubsPtr->tclGetElementOfIndexedArray)(interp, localIndex, elemPtr, leaveErrorMsg) /* 29 */
          707  +#define TclGetElementOfIndexedArray \
          708  +	(tclIntStubsPtr->tclGetElementOfIndexedArray) /* 29 */
   709    709   #endif
   710    710   /* Slot 30 is reserved */
   711    711   #ifndef TclGetExtension
   712         -#define TclGetExtension(name) \
   713         -	(tclIntStubsPtr->tclGetExtension)(name) /* 31 */
          712  +#define TclGetExtension \
          713  +	(tclIntStubsPtr->tclGetExtension) /* 31 */
   714    714   #endif
   715    715   #ifndef TclGetFrame
   716         -#define TclGetFrame(interp, str, framePtrPtr) \
   717         -	(tclIntStubsPtr->tclGetFrame)(interp, str, framePtrPtr) /* 32 */
          716  +#define TclGetFrame \
          717  +	(tclIntStubsPtr->tclGetFrame) /* 32 */
   718    718   #endif
   719    719   #ifndef TclGetInterpProc
   720         -#define TclGetInterpProc() \
   721         -	(tclIntStubsPtr->tclGetInterpProc)() /* 33 */
          720  +#define TclGetInterpProc \
          721  +	(tclIntStubsPtr->tclGetInterpProc) /* 33 */
   722    722   #endif
   723    723   #ifndef TclGetIntForIndex
   724         -#define TclGetIntForIndex(interp, objPtr, endValue, indexPtr) \
   725         -	(tclIntStubsPtr->tclGetIntForIndex)(interp, objPtr, endValue, indexPtr) /* 34 */
          724  +#define TclGetIntForIndex \
          725  +	(tclIntStubsPtr->tclGetIntForIndex) /* 34 */
   726    726   #endif
   727    727   #ifndef TclGetIndexedScalar
   728         -#define TclGetIndexedScalar(interp, localIndex, leaveErrorMsg) \
   729         -	(tclIntStubsPtr->tclGetIndexedScalar)(interp, localIndex, leaveErrorMsg) /* 35 */
          728  +#define TclGetIndexedScalar \
          729  +	(tclIntStubsPtr->tclGetIndexedScalar) /* 35 */
   730    730   #endif
   731    731   #ifndef TclGetLong
   732         -#define TclGetLong(interp, str, longPtr) \
   733         -	(tclIntStubsPtr->tclGetLong)(interp, str, longPtr) /* 36 */
          732  +#define TclGetLong \
          733  +	(tclIntStubsPtr->tclGetLong) /* 36 */
   734    734   #endif
   735    735   #ifndef TclGetLoadedPackages
   736         -#define TclGetLoadedPackages(interp, targetName) \
   737         -	(tclIntStubsPtr->tclGetLoadedPackages)(interp, targetName) /* 37 */
          736  +#define TclGetLoadedPackages \
          737  +	(tclIntStubsPtr->tclGetLoadedPackages) /* 37 */
   738    738   #endif
   739    739   #ifndef TclGetNamespaceForQualName
   740         -#define TclGetNamespaceForQualName(interp, qualName, cxtNsPtr, flags, nsPtrPtr, altNsPtrPtr, actualCxtPtrPtr, simpleNamePtr) \
   741         -	(tclIntStubsPtr->tclGetNamespaceForQualName)(interp, qualName, cxtNsPtr, flags, nsPtrPtr, altNsPtrPtr, actualCxtPtrPtr, simpleNamePtr) /* 38 */
          740  +#define TclGetNamespaceForQualName \
          741  +	(tclIntStubsPtr->tclGetNamespaceForQualName) /* 38 */
   742    742   #endif
   743    743   #ifndef TclGetObjInterpProc
   744         -#define TclGetObjInterpProc() \
   745         -	(tclIntStubsPtr->tclGetObjInterpProc)() /* 39 */
          744  +#define TclGetObjInterpProc \
          745  +	(tclIntStubsPtr->tclGetObjInterpProc) /* 39 */
   746    746   #endif
   747    747   #ifndef TclGetOpenMode
   748         -#define TclGetOpenMode(interp, str, seekFlagPtr) \
   749         -	(tclIntStubsPtr->tclGetOpenMode)(interp, str, seekFlagPtr) /* 40 */
          748  +#define TclGetOpenMode \
          749  +	(tclIntStubsPtr->tclGetOpenMode) /* 40 */
   750    750   #endif
   751    751   #ifndef TclGetOriginalCommand
   752         -#define TclGetOriginalCommand(command) \
   753         -	(tclIntStubsPtr->tclGetOriginalCommand)(command) /* 41 */
          752  +#define TclGetOriginalCommand \
          753  +	(tclIntStubsPtr->tclGetOriginalCommand) /* 41 */
   754    754   #endif
   755    755   #ifndef TclpGetUserHome
   756         -#define TclpGetUserHome(name, bufferPtr) \
   757         -	(tclIntStubsPtr->tclpGetUserHome)(name, bufferPtr) /* 42 */
          756  +#define TclpGetUserHome \
          757  +	(tclIntStubsPtr->tclpGetUserHome) /* 42 */
   758    758   #endif
   759    759   #ifndef TclGlobalInvoke
   760         -#define TclGlobalInvoke(interp, argc, argv, flags) \
   761         -	(tclIntStubsPtr->tclGlobalInvoke)(interp, argc, argv, flags) /* 43 */
          760  +#define TclGlobalInvoke \
          761  +	(tclIntStubsPtr->tclGlobalInvoke) /* 43 */
   762    762   #endif
   763    763   #ifndef TclGuessPackageName
   764         -#define TclGuessPackageName(fileName, bufPtr) \
   765         -	(tclIntStubsPtr->tclGuessPackageName)(fileName, bufPtr) /* 44 */
          764  +#define TclGuessPackageName \
          765  +	(tclIntStubsPtr->tclGuessPackageName) /* 44 */
   766    766   #endif
   767    767   #ifndef TclHideUnsafeCommands
   768         -#define TclHideUnsafeCommands(interp) \
   769         -	(tclIntStubsPtr->tclHideUnsafeCommands)(interp) /* 45 */
          768  +#define TclHideUnsafeCommands \
          769  +	(tclIntStubsPtr->tclHideUnsafeCommands) /* 45 */
   770    770   #endif
   771    771   #ifndef TclInExit
   772         -#define TclInExit() \
   773         -	(tclIntStubsPtr->tclInExit)() /* 46 */
          772  +#define TclInExit \
          773  +	(tclIntStubsPtr->tclInExit) /* 46 */
   774    774   #endif
   775    775   #ifndef TclIncrElementOfIndexedArray
   776         -#define TclIncrElementOfIndexedArray(interp, localIndex, elemPtr, incrAmount) \
   777         -	(tclIntStubsPtr->tclIncrElementOfIndexedArray)(interp, localIndex, elemPtr, incrAmount) /* 47 */
          776  +#define TclIncrElementOfIndexedArray \
          777  +	(tclIntStubsPtr->tclIncrElementOfIndexedArray) /* 47 */
   778    778   #endif
   779    779   #ifndef TclIncrIndexedScalar
   780         -#define TclIncrIndexedScalar(interp, localIndex, incrAmount) \
   781         -	(tclIntStubsPtr->tclIncrIndexedScalar)(interp, localIndex, incrAmount) /* 48 */
          780  +#define TclIncrIndexedScalar \
          781  +	(tclIntStubsPtr->tclIncrIndexedScalar) /* 48 */
   782    782   #endif
   783    783   #ifndef TclIncrVar2
   784         -#define TclIncrVar2(interp, part1Ptr, part2Ptr, incrAmount, part1NotParsed) \
   785         -	(tclIntStubsPtr->tclIncrVar2)(interp, part1Ptr, part2Ptr, incrAmount, part1NotParsed) /* 49 */
          784  +#define TclIncrVar2 \
          785  +	(tclIntStubsPtr->tclIncrVar2) /* 49 */
   786    786   #endif
   787    787   #ifndef TclInitCompiledLocals
   788         -#define TclInitCompiledLocals(interp, framePtr, nsPtr) \
   789         -	(tclIntStubsPtr->tclInitCompiledLocals)(interp, framePtr, nsPtr) /* 50 */
          788  +#define TclInitCompiledLocals \
          789  +	(tclIntStubsPtr->tclInitCompiledLocals) /* 50 */
   790    790   #endif
   791    791   #ifndef TclInterpInit
   792         -#define TclInterpInit(interp) \
   793         -	(tclIntStubsPtr->tclInterpInit)(interp) /* 51 */
          792  +#define TclInterpInit \
          793  +	(tclIntStubsPtr->tclInterpInit) /* 51 */
   794    794   #endif
   795    795   #ifndef TclInvoke
   796         -#define TclInvoke(interp, argc, argv, flags) \
   797         -	(tclIntStubsPtr->tclInvoke)(interp, argc, argv, flags) /* 52 */
          796  +#define TclInvoke \
          797  +	(tclIntStubsPtr->tclInvoke) /* 52 */
   798    798   #endif
   799    799   #ifndef TclInvokeObjectCommand
   800         -#define TclInvokeObjectCommand(clientData, interp, argc, argv) \
   801         -	(tclIntStubsPtr->tclInvokeObjectCommand)(clientData, interp, argc, argv) /* 53 */
          800  +#define TclInvokeObjectCommand \
          801  +	(tclIntStubsPtr->tclInvokeObjectCommand) /* 53 */
   802    802   #endif
   803    803   #ifndef TclInvokeStringCommand
   804         -#define TclInvokeStringCommand(clientData, interp, objc, objv) \
   805         -	(tclIntStubsPtr->tclInvokeStringCommand)(clientData, interp, objc, objv) /* 54 */
          804  +#define TclInvokeStringCommand \
          805  +	(tclIntStubsPtr->tclInvokeStringCommand) /* 54 */
   806    806   #endif
   807    807   #ifndef TclIsProc
   808         -#define TclIsProc(cmdPtr) \
   809         -	(tclIntStubsPtr->tclIsProc)(cmdPtr) /* 55 */
          808  +#define TclIsProc \
          809  +	(tclIntStubsPtr->tclIsProc) /* 55 */
   810    810   #endif
   811    811   /* Slot 56 is reserved */
   812    812   /* Slot 57 is reserved */
   813    813   #ifndef TclLookupVar
   814         -#define TclLookupVar(interp, part1, part2, flags, msg, createPart1, createPart2, arrayPtrPtr) \
   815         -	(tclIntStubsPtr->tclLookupVar)(interp, part1, part2, flags, msg, createPart1, createPart2, arrayPtrPtr) /* 58 */
          814  +#define TclLookupVar \
          815  +	(tclIntStubsPtr->tclLookupVar) /* 58 */
   816    816   #endif
   817    817   #ifndef TclpMatchFiles
   818         -#define TclpMatchFiles(interp, separators, dirPtr, pattern, tail) \
   819         -	(tclIntStubsPtr->tclpMatchFiles)(interp, separators, dirPtr, pattern, tail) /* 59 */
          818  +#define TclpMatchFiles \
          819  +	(tclIntStubsPtr->tclpMatchFiles) /* 59 */
   820    820   #endif
   821    821   #ifndef TclNeedSpace
   822         -#define TclNeedSpace(start, end) \
   823         -	(tclIntStubsPtr->tclNeedSpace)(start, end) /* 60 */
          822  +#define TclNeedSpace \
          823  +	(tclIntStubsPtr->tclNeedSpace) /* 60 */
   824    824   #endif
   825    825   #ifndef TclNewProcBodyObj
   826         -#define TclNewProcBodyObj(procPtr) \
   827         -	(tclIntStubsPtr->tclNewProcBodyObj)(procPtr) /* 61 */
          826  +#define TclNewProcBodyObj \
          827  +	(tclIntStubsPtr->tclNewProcBodyObj) /* 61 */
   828    828   #endif
   829    829   #ifndef TclObjCommandComplete
   830         -#define TclObjCommandComplete(cmdPtr) \
   831         -	(tclIntStubsPtr->tclObjCommandComplete)(cmdPtr) /* 62 */
          830  +#define TclObjCommandComplete \
          831  +	(tclIntStubsPtr->tclObjCommandComplete) /* 62 */
   832    832   #endif
   833    833   #ifndef TclObjInterpProc
   834         -#define TclObjInterpProc(clientData, interp, objc, objv) \
   835         -	(tclIntStubsPtr->tclObjInterpProc)(clientData, interp, objc, objv) /* 63 */
          834  +#define TclObjInterpProc \
          835  +	(tclIntStubsPtr->tclObjInterpProc) /* 63 */
   836    836   #endif
   837    837   #ifndef TclObjInvoke
   838         -#define TclObjInvoke(interp, objc, objv, flags) \
   839         -	(tclIntStubsPtr->tclObjInvoke)(interp, objc, objv, flags) /* 64 */
          838  +#define TclObjInvoke \
          839  +	(tclIntStubsPtr->tclObjInvoke) /* 64 */
   840    840   #endif
   841    841   #ifndef TclObjInvokeGlobal
   842         -#define TclObjInvokeGlobal(interp, objc, objv, flags) \
   843         -	(tclIntStubsPtr->tclObjInvokeGlobal)(interp, objc, objv, flags) /* 65 */
          842  +#define TclObjInvokeGlobal \
          843  +	(tclIntStubsPtr->tclObjInvokeGlobal) /* 65 */
   844    844   #endif
   845    845   #ifndef TclOpenFileChannelDeleteProc
   846         -#define TclOpenFileChannelDeleteProc(proc) \
   847         -	(tclIntStubsPtr->tclOpenFileChannelDeleteProc)(proc) /* 66 */
          846  +#define TclOpenFileChannelDeleteProc \
          847  +	(tclIntStubsPtr->tclOpenFileChannelDeleteProc) /* 66 */
   848    848   #endif
   849    849   #ifndef TclOpenFileChannelInsertProc
   850         -#define TclOpenFileChannelInsertProc(proc) \
   851         -	(tclIntStubsPtr->tclOpenFileChannelInsertProc)(proc) /* 67 */
          850  +#define TclOpenFileChannelInsertProc \
          851  +	(tclIntStubsPtr->tclOpenFileChannelInsertProc) /* 67 */
   852    852   #endif
   853    853   #ifndef TclpAccess
   854         -#define TclpAccess(path, mode) \
   855         -	(tclIntStubsPtr->tclpAccess)(path, mode) /* 68 */
          854  +#define TclpAccess \
          855  +	(tclIntStubsPtr->tclpAccess) /* 68 */
   856    856   #endif
   857    857   #ifndef TclpAlloc
   858         -#define TclpAlloc(size) \
   859         -	(tclIntStubsPtr->tclpAlloc)(size) /* 69 */
          858  +#define TclpAlloc \
          859  +	(tclIntStubsPtr->tclpAlloc) /* 69 */
   860    860   #endif
   861    861   #ifndef TclpCopyFile
   862         -#define TclpCopyFile(source, dest) \
   863         -	(tclIntStubsPtr->tclpCopyFile)(source, dest) /* 70 */
          862  +#define TclpCopyFile \
          863  +	(tclIntStubsPtr->tclpCopyFile) /* 70 */
   864    864   #endif
   865    865   #ifndef TclpCopyDirectory
   866         -#define TclpCopyDirectory(source, dest, errorPtr) \
   867         -	(tclIntStubsPtr->tclpCopyDirectory)(source, dest, errorPtr) /* 71 */
          866  +#define TclpCopyDirectory \
          867  +	(tclIntStubsPtr->tclpCopyDirectory) /* 71 */
   868    868   #endif
   869    869   #ifndef TclpCreateDirectory
   870         -#define TclpCreateDirectory(path) \
   871         -	(tclIntStubsPtr->tclpCreateDirectory)(path) /* 72 */
          870  +#define TclpCreateDirectory \
          871  +	(tclIntStubsPtr->tclpCreateDirectory) /* 72 */
   872    872   #endif
   873    873   #ifndef TclpDeleteFile
   874         -#define TclpDeleteFile(path) \
   875         -	(tclIntStubsPtr->tclpDeleteFile)(path) /* 73 */
          874  +#define TclpDeleteFile \
          875  +	(tclIntStubsPtr->tclpDeleteFile) /* 73 */
   876    876   #endif
   877    877   #ifndef TclpFree
   878         -#define TclpFree(ptr) \
   879         -	(tclIntStubsPtr->tclpFree)(ptr) /* 74 */
          878  +#define TclpFree \
          879  +	(tclIntStubsPtr->tclpFree) /* 74 */
   880    880   #endif
   881    881   #ifndef TclpGetClicks
   882         -#define TclpGetClicks() \
   883         -	(tclIntStubsPtr->tclpGetClicks)() /* 75 */
          882  +#define TclpGetClicks \
          883  +	(tclIntStubsPtr->tclpGetClicks) /* 75 */
   884    884   #endif
   885    885   #ifndef TclpGetSeconds
   886         -#define TclpGetSeconds() \
   887         -	(tclIntStubsPtr->tclpGetSeconds)() /* 76 */
          886  +#define TclpGetSeconds \
          887  +	(tclIntStubsPtr->tclpGetSeconds) /* 76 */
   888    888   #endif
   889    889   #ifndef TclpGetTime
   890         -#define TclpGetTime(time) \
   891         -	(tclIntStubsPtr->tclpGetTime)(time) /* 77 */
          890  +#define TclpGetTime \
          891  +	(tclIntStubsPtr->tclpGetTime) /* 77 */
   892    892   #endif
   893    893   #ifndef TclpGetTimeZone
   894         -#define TclpGetTimeZone(time) \
   895         -	(tclIntStubsPtr->tclpGetTimeZone)(time) /* 78 */
          894  +#define TclpGetTimeZone \
          895  +	(tclIntStubsPtr->tclpGetTimeZone) /* 78 */
   896    896   #endif
   897    897   #ifndef TclpListVolumes
   898         -#define TclpListVolumes(interp) \
   899         -	(tclIntStubsPtr->tclpListVolumes)(interp) /* 79 */
          898  +#define TclpListVolumes \
          899  +	(tclIntStubsPtr->tclpListVolumes) /* 79 */
   900    900   #endif
   901    901   #ifndef TclpOpenFileChannel
   902         -#define TclpOpenFileChannel(interp, fileName, modeString, permissions) \
   903         -	(tclIntStubsPtr->tclpOpenFileChannel)(interp, fileName, modeString, permissions) /* 80 */
          902  +#define TclpOpenFileChannel \
          903  +	(tclIntStubsPtr->tclpOpenFileChannel) /* 80 */
   904    904   #endif
   905    905   #ifndef TclpRealloc
   906         -#define TclpRealloc(ptr, size) \
   907         -	(tclIntStubsPtr->tclpRealloc)(ptr, size) /* 81 */
          906  +#define TclpRealloc \
          907  +	(tclIntStubsPtr->tclpRealloc) /* 81 */
   908    908   #endif
   909    909   #ifndef TclpRemoveDirectory
   910         -#define TclpRemoveDirectory(path, recursive, errorPtr) \
   911         -	(tclIntStubsPtr->tclpRemoveDirectory)(path, recursive, errorPtr) /* 82 */
          910  +#define TclpRemoveDirectory \
          911  +	(tclIntStubsPtr->tclpRemoveDirectory) /* 82 */
   912    912   #endif
   913    913   #ifndef TclpRenameFile
   914         -#define TclpRenameFile(source, dest) \
   915         -	(tclIntStubsPtr->tclpRenameFile)(source, dest) /* 83 */
          914  +#define TclpRenameFile \
          915  +	(tclIntStubsPtr->tclpRenameFile) /* 83 */
   916    916   #endif
   917    917   /* Slot 84 is reserved */
   918    918   /* Slot 85 is reserved */
   919    919   /* Slot 86 is reserved */
   920    920   /* Slot 87 is reserved */
   921    921   #ifndef TclPrecTraceProc
   922         -#define TclPrecTraceProc(clientData, interp, name1, name2, flags) \
   923         -	(tclIntStubsPtr->tclPrecTraceProc)(clientData, interp, name1, name2, flags) /* 88 */
          922  +#define TclPrecTraceProc \
          923  +	(tclIntStubsPtr->tclPrecTraceProc) /* 88 */
   924    924   #endif
   925    925   #ifndef TclPreventAliasLoop
   926         -#define TclPreventAliasLoop(interp, cmdInterp, cmd) \
   927         -	(tclIntStubsPtr->tclPreventAliasLoop)(interp, cmdInterp, cmd) /* 89 */
          926  +#define TclPreventAliasLoop \
          927  +	(tclIntStubsPtr->tclPreventAliasLoop) /* 89 */
   928    928   #endif
   929    929   /* Slot 90 is reserved */
   930    930   #ifndef TclProcCleanupProc
   931         -#define TclProcCleanupProc(procPtr) \
   932         -	(tclIntStubsPtr->tclProcCleanupProc)(procPtr) /* 91 */
          931  +#define TclProcCleanupProc \
          932  +	(tclIntStubsPtr->tclProcCleanupProc) /* 91 */
   933    933   #endif
   934    934   #ifndef TclProcCompileProc
   935         -#define TclProcCompileProc(interp, procPtr, bodyPtr, nsPtr, description, procName) \
   936         -	(tclIntStubsPtr->tclProcCompileProc)(interp, procPtr, bodyPtr, nsPtr, description, procName) /* 92 */
          935  +#define TclProcCompileProc \
          936  +	(tclIntStubsPtr->tclProcCompileProc) /* 92 */
   937    937   #endif
   938    938   #ifndef TclProcDeleteProc
   939         -#define TclProcDeleteProc(clientData) \
   940         -	(tclIntStubsPtr->tclProcDeleteProc)(clientData) /* 93 */
          939  +#define TclProcDeleteProc \
          940  +	(tclIntStubsPtr->tclProcDeleteProc) /* 93 */
   941    941   #endif
   942    942   #ifndef TclProcInterpProc
   943         -#define TclProcInterpProc(clientData, interp, argc, argv) \
   944         -	(tclIntStubsPtr->tclProcInterpProc)(clientData, interp, argc, argv) /* 94 */
          943  +#define TclProcInterpProc \
          944  +	(tclIntStubsPtr->tclProcInterpProc) /* 94 */
   945    945   #endif
   946    946   #ifndef TclpStat
   947         -#define TclpStat(path, buf) \
   948         -	(tclIntStubsPtr->tclpStat)(path, buf) /* 95 */
          947  +#define TclpStat \
          948  +	(tclIntStubsPtr->tclpStat) /* 95 */
   949    949   #endif
   950    950   #ifndef TclRenameCommand
   951         -#define TclRenameCommand(interp, oldName, newName) \
   952         -	(tclIntStubsPtr->tclRenameCommand)(interp, oldName, newName) /* 96 */
          951  +#define TclRenameCommand \
          952  +	(tclIntStubsPtr->tclRenameCommand) /* 96 */
   953    953   #endif
   954    954   #ifndef TclResetShadowedCmdRefs
   955         -#define TclResetShadowedCmdRefs(interp, newCmdPtr) \
   956         -	(tclIntStubsPtr->tclResetShadowedCmdRefs)(interp, newCmdPtr) /* 97 */
          955  +#define TclResetShadowedCmdRefs \
          956  +	(tclIntStubsPtr->tclResetShadowedCmdRefs) /* 97 */
   957    957   #endif
   958    958   #ifndef TclServiceIdle
   959         -#define TclServiceIdle() \
   960         -	(tclIntStubsPtr->tclServiceIdle)() /* 98 */
          959  +#define TclServiceIdle \
          960  +	(tclIntStubsPtr->tclServiceIdle) /* 98 */
   961    961   #endif
   962    962   #ifndef TclSetElementOfIndexedArray
   963         -#define TclSetElementOfIndexedArray(interp, localIndex, elemPtr, objPtr, leaveErrorMsg) \
   964         -	(tclIntStubsPtr->tclSetElementOfIndexedArray)(interp, localIndex, elemPtr, objPtr, leaveErrorMsg) /* 99 */
          963  +#define TclSetElementOfIndexedArray \
          964  +	(tclIntStubsPtr->tclSetElementOfIndexedArray) /* 99 */
   965    965   #endif
   966    966   #ifndef TclSetIndexedScalar
   967         -#define TclSetIndexedScalar(interp, localIndex, objPtr, leaveErrorMsg) \
   968         -	(tclIntStubsPtr->tclSetIndexedScalar)(interp, localIndex, objPtr, leaveErrorMsg) /* 100 */
          967  +#define TclSetIndexedScalar \
          968  +	(tclIntStubsPtr->tclSetIndexedScalar) /* 100 */
   969    969   #endif
   970    970   /* Slot 101 is reserved */
   971    971   #ifndef TclSetupEnv
   972         -#define TclSetupEnv(interp) \
   973         -	(tclIntStubsPtr->tclSetupEnv)(interp) /* 102 */
          972  +#define TclSetupEnv \
          973  +	(tclIntStubsPtr->tclSetupEnv) /* 102 */
   974    974   #endif
   975    975   #ifndef TclSockGetPort
   976         -#define TclSockGetPort(interp, str, proto, portPtr) \
   977         -	(tclIntStubsPtr->tclSockGetPort)(interp, str, proto, portPtr) /* 103 */
          976  +#define TclSockGetPort \
          977  +	(tclIntStubsPtr->tclSockGetPort) /* 103 */
   978    978   #endif
   979    979   #ifndef TclSockMinimumBuffers
   980         -#define TclSockMinimumBuffers(sock, size) \
   981         -	(tclIntStubsPtr->tclSockMinimumBuffers)(sock, size) /* 104 */
          980  +#define TclSockMinimumBuffers \
          981  +	(tclIntStubsPtr->tclSockMinimumBuffers) /* 104 */
   982    982   #endif
   983    983   #ifndef TclStat
   984         -#define TclStat(path, buf) \
   985         -	(tclIntStubsPtr->tclStat)(path, buf) /* 105 */
          984  +#define TclStat \
          985  +	(tclIntStubsPtr->tclStat) /* 105 */
   986    986   #endif
   987    987   #ifndef TclStatDeleteProc
   988         -#define TclStatDeleteProc(proc) \
   989         -	(tclIntStubsPtr->tclStatDeleteProc)(proc) /* 106 */
          988  +#define TclStatDeleteProc \
          989  +	(tclIntStubsPtr->tclStatDeleteProc) /* 106 */
   990    990   #endif
   991    991   #ifndef TclStatInsertProc
   992         -#define TclStatInsertProc(proc) \
   993         -	(tclIntStubsPtr->tclStatInsertProc)(proc) /* 107 */
          992  +#define TclStatInsertProc \
          993  +	(tclIntStubsPtr->tclStatInsertProc) /* 107 */
   994    994   #endif
   995    995   #ifndef TclTeardownNamespace
   996         -#define TclTeardownNamespace(nsPtr) \
   997         -	(tclIntStubsPtr->tclTeardownNamespace)(nsPtr) /* 108 */
          996  +#define TclTeardownNamespace \
          997  +	(tclIntStubsPtr->tclTeardownNamespace) /* 108 */
   998    998   #endif
   999    999   #ifndef TclUpdateReturnInfo
  1000         -#define TclUpdateReturnInfo(iPtr) \
  1001         -	(tclIntStubsPtr->tclUpdateReturnInfo)(iPtr) /* 109 */
         1000  +#define TclUpdateReturnInfo \
         1001  +	(tclIntStubsPtr->tclUpdateReturnInfo) /* 109 */
  1002   1002   #endif
  1003   1003   /* Slot 110 is reserved */
  1004   1004   #ifndef Tcl_AddInterpResolvers
  1005         -#define Tcl_AddInterpResolvers(interp, name, cmdProc, varProc, compiledVarProc) \
  1006         -	(tclIntStubsPtr->tcl_AddInterpResolvers)(interp, name, cmdProc, varProc, compiledVarProc) /* 111 */
         1005  +#define Tcl_AddInterpResolvers \
         1006  +	(tclIntStubsPtr->tcl_AddInterpResolvers) /* 111 */
  1007   1007   #endif
  1008   1008   #ifndef Tcl_AppendExportList
  1009         -#define Tcl_AppendExportList(interp, nsPtr, objPtr) \
  1010         -	(tclIntStubsPtr->tcl_AppendExportList)(interp, nsPtr, objPtr) /* 112 */
         1009  +#define Tcl_AppendExportList \
         1010  +	(tclIntStubsPtr->tcl_AppendExportList) /* 112 */
  1011   1011   #endif
  1012   1012   #ifndef Tcl_CreateNamespace
  1013         -#define Tcl_CreateNamespace(interp, name, clientData, deleteProc) \
  1014         -	(tclIntStubsPtr->tcl_CreateNamespace)(interp, name, clientData, deleteProc) /* 113 */
         1013  +#define Tcl_CreateNamespace \
         1014  +	(tclIntStubsPtr->tcl_CreateNamespace) /* 113 */
  1015   1015   #endif
  1016   1016   #ifndef Tcl_DeleteNamespace
  1017         -#define Tcl_DeleteNamespace(nsPtr) \
  1018         -	(tclIntStubsPtr->tcl_DeleteNamespace)(nsPtr) /* 114 */
         1017  +#define Tcl_DeleteNamespace \
         1018  +	(tclIntStubsPtr->tcl_DeleteNamespace) /* 114 */
  1019   1019   #endif
  1020   1020   #ifndef Tcl_Export
  1021         -#define Tcl_Export(interp, nsPtr, pattern, resetListFirst) \
  1022         -	(tclIntStubsPtr->tcl_Export)(interp, nsPtr, pattern, resetListFirst) /* 115 */
         1021  +#define Tcl_Export \
         1022  +	(tclIntStubsPtr->tcl_Export) /* 115 */
  1023   1023   #endif
  1024   1024   #ifndef Tcl_FindCommand
  1025         -#define Tcl_FindCommand(interp, name, contextNsPtr, flags) \
  1026         -	(tclIntStubsPtr->tcl_FindCommand)(interp, name, contextNsPtr, flags) /* 116 */
         1025  +#define Tcl_FindCommand \
         1026  +	(tclIntStubsPtr->tcl_FindCommand) /* 116 */
  1027   1027   #endif
  1028   1028   #ifndef Tcl_FindNamespace
  1029         -#define Tcl_FindNamespace(interp, name, contextNsPtr, flags) \
  1030         -	(tclIntStubsPtr->tcl_FindNamespace)(interp, name, contextNsPtr, flags) /* 117 */
         1029  +#define Tcl_FindNamespace \
         1030  +	(tclIntStubsPtr->tcl_FindNamespace) /* 117 */
  1031   1031   #endif
  1032   1032   #ifndef Tcl_GetInterpResolvers
  1033         -#define Tcl_GetInterpResolvers(interp, name, resInfo) \
  1034         -	(tclIntStubsPtr->tcl_GetInterpResolvers)(interp, name, resInfo) /* 118 */
         1033  +#define Tcl_GetInterpResolvers \
         1034  +	(tclIntStubsPtr->tcl_GetInterpResolvers) /* 118 */
  1035   1035   #endif
  1036   1036   #ifndef Tcl_GetNamespaceResolvers
  1037         -#define Tcl_GetNamespaceResolvers(namespacePtr, resInfo) \
  1038         -	(tclIntStubsPtr->tcl_GetNamespaceResolvers)(namespacePtr, resInfo) /* 119 */
         1037  +#define Tcl_GetNamespaceResolvers \
         1038  +	(tclIntStubsPtr->tcl_GetNamespaceResolvers) /* 119 */
  1039   1039   #endif
  1040   1040   #ifndef Tcl_FindNamespaceVar
  1041         -#define Tcl_FindNamespaceVar(interp, name, contextNsPtr, flags) \
  1042         -	(tclIntStubsPtr->tcl_FindNamespaceVar)(interp, name, contextNsPtr, flags) /* 120 */
         1041  +#define Tcl_FindNamespaceVar \
         1042  +	(tclIntStubsPtr->tcl_FindNamespaceVar) /* 120 */
  1043   1043   #endif
  1044   1044   #ifndef Tcl_ForgetImport
  1045         -#define Tcl_ForgetImport(interp, nsPtr, pattern) \
  1046         -	(tclIntStubsPtr->tcl_ForgetImport)(interp, nsPtr, pattern) /* 121 */
         1045  +#define Tcl_ForgetImport \
         1046  +	(tclIntStubsPtr->tcl_ForgetImport) /* 121 */
  1047   1047   #endif
  1048   1048   #ifndef Tcl_GetCommandFromObj
  1049         -#define Tcl_GetCommandFromObj(interp, objPtr) \
  1050         -	(tclIntStubsPtr->tcl_GetCommandFromObj)(interp, objPtr) /* 122 */
         1049  +#define Tcl_GetCommandFromObj \
         1050  +	(tclIntStubsPtr->tcl_GetCommandFromObj) /* 122 */
  1051   1051   #endif
  1052   1052   #ifndef Tcl_GetCommandFullName
  1053         -#define Tcl_GetCommandFullName(interp, command, objPtr) \
  1054         -	(tclIntStubsPtr->tcl_GetCommandFullName)(interp, command, objPtr) /* 123 */
         1053  +#define Tcl_GetCommandFullName \
         1054  +	(tclIntStubsPtr->tcl_GetCommandFullName) /* 123 */
  1055   1055   #endif
  1056   1056   #ifndef Tcl_GetCurrentNamespace
  1057         -#define Tcl_GetCurrentNamespace(interp) \
  1058         -	(tclIntStubsPtr->tcl_GetCurrentNamespace)(interp) /* 124 */
         1057  +#define Tcl_GetCurrentNamespace \
         1058  +	(tclIntStubsPtr->tcl_GetCurrentNamespace) /* 124 */
  1059   1059   #endif
  1060   1060   #ifndef Tcl_GetGlobalNamespace
  1061         -#define Tcl_GetGlobalNamespace(interp) \
  1062         -	(tclIntStubsPtr->tcl_GetGlobalNamespace)(interp) /* 125 */
         1061  +#define Tcl_GetGlobalNamespace \
         1062  +	(tclIntStubsPtr->tcl_GetGlobalNamespace) /* 125 */
  1063   1063   #endif
  1064   1064   #ifndef Tcl_GetVariableFullName
  1065         -#define Tcl_GetVariableFullName(interp, variable, objPtr) \
  1066         -	(tclIntStubsPtr->tcl_GetVariableFullName)(interp, variable, objPtr) /* 126 */
         1065  +#define Tcl_GetVariableFullName \
         1066  +	(tclIntStubsPtr->tcl_GetVariableFullName) /* 126 */
  1067   1067   #endif
  1068   1068   #ifndef Tcl_Import
  1069         -#define Tcl_Import(interp, nsPtr, pattern, allowOverwrite) \
  1070         -	(tclIntStubsPtr->tcl_Import)(interp, nsPtr, pattern, allowOverwrite) /* 127 */
         1069  +#define Tcl_Import \
         1070  +	(tclIntStubsPtr->tcl_Import) /* 127 */
  1071   1071   #endif
  1072   1072   #ifndef Tcl_PopCallFrame
  1073         -#define Tcl_PopCallFrame(interp) \
  1074         -	(tclIntStubsPtr->tcl_PopCallFrame)(interp) /* 128 */
         1073  +#define Tcl_PopCallFrame \
         1074  +	(tclIntStubsPtr->tcl_PopCallFrame) /* 128 */
  1075   1075   #endif
  1076   1076   #ifndef Tcl_PushCallFrame
  1077         -#define Tcl_PushCallFrame(interp, framePtr, nsPtr, isProcCallFrame) \
  1078         -	(tclIntStubsPtr->tcl_PushCallFrame)(interp, framePtr, nsPtr, isProcCallFrame) /* 129 */
         1077  +#define Tcl_PushCallFrame \
         1078  +	(tclIntStubsPtr->tcl_PushCallFrame) /* 129 */
  1079   1079   #endif
  1080   1080   #ifndef Tcl_RemoveInterpResolvers
  1081         -#define Tcl_RemoveInterpResolvers(interp, name) \
  1082         -	(tclIntStubsPtr->tcl_RemoveInterpResolvers)(interp, name) /* 130 */
         1081  +#define Tcl_RemoveInterpResolvers \
         1082  +	(tclIntStubsPtr->tcl_RemoveInterpResolvers) /* 130 */
  1083   1083   #endif
  1084   1084   #ifndef Tcl_SetNamespaceResolvers
  1085         -#define Tcl_SetNamespaceResolvers(namespacePtr, cmdProc, varProc, compiledVarProc) \
  1086         -	(tclIntStubsPtr->tcl_SetNamespaceResolvers)(namespacePtr, cmdProc, varProc, compiledVarProc) /* 131 */
         1085  +#define Tcl_SetNamespaceResolvers \
         1086  +	(tclIntStubsPtr->tcl_SetNamespaceResolvers) /* 131 */
  1087   1087   #endif
  1088   1088   #ifndef TclpHasSockets
  1089         -#define TclpHasSockets(interp) \
  1090         -	(tclIntStubsPtr->tclpHasSockets)(interp) /* 132 */
         1089  +#define TclpHasSockets \
         1090  +	(tclIntStubsPtr->tclpHasSockets) /* 132 */
  1091   1091   #endif
  1092   1092   #ifndef TclpGetDate
  1093         -#define TclpGetDate(time, useGMT) \
  1094         -	(tclIntStubsPtr->tclpGetDate)(time, useGMT) /* 133 */
         1093  +#define TclpGetDate \
         1094  +	(tclIntStubsPtr->tclpGetDate) /* 133 */
  1095   1095   #endif
  1096   1096   #ifndef TclpStrftime
  1097         -#define TclpStrftime(s, maxsize, format, t) \
  1098         -	(tclIntStubsPtr->tclpStrftime)(s, maxsize, format, t) /* 134 */
         1097  +#define TclpStrftime \
         1098  +	(tclIntStubsPtr->tclpStrftime) /* 134 */
  1099   1099   #endif
  1100   1100   #ifndef TclpCheckStackSpace
  1101         -#define TclpCheckStackSpace() \
  1102         -	(tclIntStubsPtr->tclpCheckStackSpace)() /* 135 */
         1101  +#define TclpCheckStackSpace \
         1102  +	(tclIntStubsPtr->tclpCheckStackSpace) /* 135 */
  1103   1103   #endif
  1104   1104   /* Slot 136 is reserved */
  1105   1105   #ifndef TclpChdir
  1106         -#define TclpChdir(dirName) \
  1107         -	(tclIntStubsPtr->tclpChdir)(dirName) /* 137 */
         1106  +#define TclpChdir \
         1107  +	(tclIntStubsPtr->tclpChdir) /* 137 */
  1108   1108   #endif
  1109   1109   #ifndef TclGetEnv
  1110         -#define TclGetEnv(name, valuePtr) \
  1111         -	(tclIntStubsPtr->tclGetEnv)(name, valuePtr) /* 138 */
         1110  +#define TclGetEnv \
         1111  +	(tclIntStubsPtr->tclGetEnv) /* 138 */
  1112   1112   #endif
  1113   1113   #ifndef TclpLoadFile
  1114         -#define TclpLoadFile(interp, fileName, sym1, sym2, proc1Ptr, proc2Ptr, clientDataPtr) \
  1115         -	(tclIntStubsPtr->tclpLoadFile)(interp, fileName, sym1, sym2, proc1Ptr, proc2Ptr, clientDataPtr) /* 139 */
         1114  +#define TclpLoadFile \
         1115  +	(tclIntStubsPtr->tclpLoadFile) /* 139 */
  1116   1116   #endif
  1117   1117   #ifndef TclLooksLikeInt
  1118         -#define TclLooksLikeInt(bytes, length) \
  1119         -	(tclIntStubsPtr->tclLooksLikeInt)(bytes, length) /* 140 */
         1118  +#define TclLooksLikeInt \
         1119  +	(tclIntStubsPtr->tclLooksLikeInt) /* 140 */
  1120   1120   #endif
  1121   1121   
  1122   1122   #endif /* defined(USE_TCL_STUBS) && !defined(USE_TCL_STUB_PROCS) */
  1123   1123   
  1124   1124   /* !END!: Do not edit above this line. */
  1125   1125   
  1126   1126   #endif /* _TCLINTDECLS */

Changes to generic/tclIntPlatDecls.h.

     5      5    *	unsupported functions that are exported by the Tcl library.  These
     6      6    *	interfaces are not guaranteed to remain the same between
     7      7    *	versions.  Use at your own risk.
     8      8    *
     9      9    * Copyright (c) 1998-1999 by Scriptics Corporation.
    10     10    * All rights reserved.
    11     11    *
    12         - * RCS: @(#) $Id: tclIntPlatDecls.h,v 1.3.2.5 1999/03/19 04:01:21 stanton Exp $
           12  + * RCS: @(#) $Id: tclIntPlatDecls.h,v 1.3.2.6 1999/03/30 01:55:53 redman Exp $
    13     13    */
    14     14   
    15     15   #ifndef _TCLINTPLATDECLS
    16     16   #define _TCLINTPLATDECLS
    17     17   
    18     18   /*
    19     19    * WARNING: This file is automatically generated by the tools/genStubs.tcl
................................................................................
   282    282   
   283    283   /*
   284    284    * Inline function declarations:
   285    285    */
   286    286   
   287    287   #if !defined(__WIN32__) && !defined(MAC_TCL) /* UNIX */
   288    288   #ifndef TclGetAndDetachPids
   289         -#define TclGetAndDetachPids(interp, chan) \
   290         -	(tclIntPlatStubsPtr->tclGetAndDetachPids)(interp, chan) /* 0 */
          289  +#define TclGetAndDetachPids \
          290  +	(tclIntPlatStubsPtr->tclGetAndDetachPids) /* 0 */
   291    291   #endif
   292    292   #ifndef TclpCloseFile
   293         -#define TclpCloseFile(file) \
   294         -	(tclIntPlatStubsPtr->tclpCloseFile)(file) /* 1 */
          293  +#define TclpCloseFile \
          294  +	(tclIntPlatStubsPtr->tclpCloseFile) /* 1 */
   295    295   #endif
   296    296   #ifndef TclpCreateCommandChannel
   297         -#define TclpCreateCommandChannel(readFile, writeFile, errorFile, numPids, pidPtr) \
   298         -	(tclIntPlatStubsPtr->tclpCreateCommandChannel)(readFile, writeFile, errorFile, numPids, pidPtr) /* 2 */
          297  +#define TclpCreateCommandChannel \
          298  +	(tclIntPlatStubsPtr->tclpCreateCommandChannel) /* 2 */
   299    299   #endif
   300    300   #ifndef TclpCreatePipe
   301         -#define TclpCreatePipe(readPipe, writePipe) \
   302         -	(tclIntPlatStubsPtr->tclpCreatePipe)(readPipe, writePipe) /* 3 */
          301  +#define TclpCreatePipe \
          302  +	(tclIntPlatStubsPtr->tclpCreatePipe) /* 3 */
   303    303   #endif
   304    304   #ifndef TclpCreateProcess
   305         -#define TclpCreateProcess(interp, argc, argv, inputFile, outputFile, errorFile, pidPtr) \
   306         -	(tclIntPlatStubsPtr->tclpCreateProcess)(interp, argc, argv, inputFile, outputFile, errorFile, pidPtr) /* 4 */
          305  +#define TclpCreateProcess \
          306  +	(tclIntPlatStubsPtr->tclpCreateProcess) /* 4 */
   307    307   #endif
   308    308   /* Slot 5 is reserved */
   309    309   #ifndef TclpMakeFile
   310         -#define TclpMakeFile(channel, direction) \
   311         -	(tclIntPlatStubsPtr->tclpMakeFile)(channel, direction) /* 6 */
          310  +#define TclpMakeFile \
          311  +	(tclIntPlatStubsPtr->tclpMakeFile) /* 6 */
   312    312   #endif
   313    313   #ifndef TclpOpenFile
   314         -#define TclpOpenFile(fname, mode) \
   315         -	(tclIntPlatStubsPtr->tclpOpenFile)(fname, mode) /* 7 */
          314  +#define TclpOpenFile \
          315  +	(tclIntPlatStubsPtr->tclpOpenFile) /* 7 */
   316    316   #endif
   317    317   #ifndef TclUnixWaitForFile
   318         -#define TclUnixWaitForFile(fd, mask, timeout) \
   319         -	(tclIntPlatStubsPtr->tclUnixWaitForFile)(fd, mask, timeout) /* 8 */
          318  +#define TclUnixWaitForFile \
          319  +	(tclIntPlatStubsPtr->tclUnixWaitForFile) /* 8 */
   320    320   #endif
   321    321   #ifndef TclpCreateTempFile
   322         -#define TclpCreateTempFile(contents) \
   323         -	(tclIntPlatStubsPtr->tclpCreateTempFile)(contents) /* 9 */
          322  +#define TclpCreateTempFile \
          323  +	(tclIntPlatStubsPtr->tclpCreateTempFile) /* 9 */
   324    324   #endif
   325    325   #endif /* UNIX */
   326    326   #ifdef __WIN32__
   327    327   #ifndef TclWinConvertError
   328         -#define TclWinConvertError(errCode) \
   329         -	(tclIntPlatStubsPtr->tclWinConvertError)(errCode) /* 0 */
          328  +#define TclWinConvertError \
          329  +	(tclIntPlatStubsPtr->tclWinConvertError) /* 0 */
   330    330   #endif
   331    331   #ifndef TclWinConvertWSAError
   332         -#define TclWinConvertWSAError(errCode) \
   333         -	(tclIntPlatStubsPtr->tclWinConvertWSAError)(errCode) /* 1 */
          332  +#define TclWinConvertWSAError \
          333  +	(tclIntPlatStubsPtr->tclWinConvertWSAError) /* 1 */
   334    334   #endif
   335    335   #ifndef TclWinGetServByName
   336         -#define TclWinGetServByName(nm, proto) \
   337         -	(tclIntPlatStubsPtr->tclWinGetServByName)(nm, proto) /* 2 */
          336  +#define TclWinGetServByName \
          337  +	(tclIntPlatStubsPtr->tclWinGetServByName) /* 2 */
   338    338   #endif
   339    339   #ifndef TclWinGetSockOpt
   340         -#define TclWinGetSockOpt(s, level, optname, optval, optlen) \
   341         -	(tclIntPlatStubsPtr->tclWinGetSockOpt)(s, level, optname, optval, optlen) /* 3 */
          340  +#define TclWinGetSockOpt \
          341  +	(tclIntPlatStubsPtr->tclWinGetSockOpt) /* 3 */
   342    342   #endif
   343    343   #ifndef TclWinGetTclInstance
   344         -#define TclWinGetTclInstance() \
   345         -	(tclIntPlatStubsPtr->tclWinGetTclInstance)() /* 4 */
          344  +#define TclWinGetTclInstance \
          345  +	(tclIntPlatStubsPtr->tclWinGetTclInstance) /* 4 */
   346    346   #endif
   347    347   /* Slot 5 is reserved */
   348    348   #ifndef TclWinNToHS
   349         -#define TclWinNToHS(ns) \
   350         -	(tclIntPlatStubsPtr->tclWinNToHS)(ns) /* 6 */
          349  +#define TclWinNToHS \
          350  +	(tclIntPlatStubsPtr->tclWinNToHS) /* 6 */
   351    351   #endif
   352    352   #ifndef TclWinSetSockOpt
   353         -#define TclWinSetSockOpt(s, level, optname, optval, optlen) \
   354         -	(tclIntPlatStubsPtr->tclWinSetSockOpt)(s, level, optname, optval, optlen) /* 7 */
          353  +#define TclWinSetSockOpt \
          354  +	(tclIntPlatStubsPtr->tclWinSetSockOpt) /* 7 */
   355    355   #endif
   356    356   #ifndef TclpGetPid
   357         -#define TclpGetPid(pid) \
   358         -	(tclIntPlatStubsPtr->tclpGetPid)(pid) /* 8 */
          357  +#define TclpGetPid \
          358  +	(tclIntPlatStubsPtr->tclpGetPid) /* 8 */
   359    359   #endif
   360    360   #ifndef TclWinGetPlatformId
   361         -#define TclWinGetPlatformId() \
   362         -	(tclIntPlatStubsPtr->tclWinGetPlatformId)() /* 9 */
          361  +#define TclWinGetPlatformId \
          362  +	(tclIntPlatStubsPtr->tclWinGetPlatformId) /* 9 */
   363    363   #endif
   364    364   #ifndef TclWinSynchSpawn
   365         -#define TclWinSynchSpawn(args, type, trans, pidPtr) \
   366         -	(tclIntPlatStubsPtr->tclWinSynchSpawn)(args, type, trans, pidPtr) /* 10 */
          365  +#define TclWinSynchSpawn \
          366  +	(tclIntPlatStubsPtr->tclWinSynchSpawn) /* 10 */
   367    367   #endif
   368    368   #ifndef TclGetAndDetachPids
   369         -#define TclGetAndDetachPids(interp, chan) \
   370         -	(tclIntPlatStubsPtr->tclGetAndDetachPids)(interp, chan) /* 11 */
          369  +#define TclGetAndDetachPids \
          370  +	(tclIntPlatStubsPtr->tclGetAndDetachPids) /* 11 */
   371    371   #endif
   372    372   #ifndef TclpCloseFile
   373         -#define TclpCloseFile(file) \
   374         -	(tclIntPlatStubsPtr->tclpCloseFile)(file) /* 12 */
          373  +#define TclpCloseFile \
          374  +	(tclIntPlatStubsPtr->tclpCloseFile) /* 12 */
   375    375   #endif
   376    376   #ifndef TclpCreateCommandChannel
   377         -#define TclpCreateCommandChannel(readFile, writeFile, errorFile, numPids, pidPtr) \
   378         -	(tclIntPlatStubsPtr->tclpCreateCommandChannel)(readFile, writeFile, errorFile, numPids, pidPtr) /* 13 */
          377  +#define TclpCreateCommandChannel \
          378  +	(tclIntPlatStubsPtr->tclpCreateCommandChannel) /* 13 */
   379    379   #endif
   380    380   #ifndef TclpCreatePipe
   381         -#define TclpCreatePipe(readPipe, writePipe) \
   382         -	(tclIntPlatStubsPtr->tclpCreatePipe)(readPipe, writePipe) /* 14 */
          381  +#define TclpCreatePipe \
          382  +	(tclIntPlatStubsPtr->tclpCreatePipe) /* 14 */
   383    383   #endif
   384    384   #ifndef TclpCreateProcess
   385         -#define TclpCreateProcess(interp, argc, argv, inputFile, outputFile, errorFile, pidPtr) \
   386         -	(tclIntPlatStubsPtr->tclpCreateProcess)(interp, argc, argv, inputFile, outputFile, errorFile, pidPtr) /* 15 */
          385  +#define TclpCreateProcess \
          386  +	(tclIntPlatStubsPtr->tclpCreateProcess) /* 15 */
   387    387   #endif
   388    388   /* Slot 16 is reserved */
   389    389   /* Slot 17 is reserved */
   390    390   #ifndef TclpMakeFile
   391         -#define TclpMakeFile(channel, direction) \
   392         -	(tclIntPlatStubsPtr->tclpMakeFile)(channel, direction) /* 18 */
          391  +#define TclpMakeFile \
          392  +	(tclIntPlatStubsPtr->tclpMakeFile) /* 18 */
   393    393   #endif
   394    394   #ifndef TclpOpenFile
   395         -#define TclpOpenFile(fname, mode) \
   396         -	(tclIntPlatStubsPtr->tclpOpenFile)(fname, mode) /* 19 */
          395  +#define TclpOpenFile \
          396  +	(tclIntPlatStubsPtr->tclpOpenFile) /* 19 */
   397    397   #endif
   398    398   #ifndef TclWinAddProcess
   399         -#define TclWinAddProcess(hProcess, id) \
   400         -	(tclIntPlatStubsPtr->tclWinAddProcess)(hProcess, id) /* 20 */
          399  +#define TclWinAddProcess \
          400  +	(tclIntPlatStubsPtr->tclWinAddProcess) /* 20 */
   401    401   #endif
   402    402   #ifndef TclpAsyncMark
   403         -#define TclpAsyncMark(async) \
   404         -	(tclIntPlatStubsPtr->tclpAsyncMark)(async) /* 21 */
          403  +#define TclpAsyncMark \
          404  +	(tclIntPlatStubsPtr->tclpAsyncMark) /* 21 */
   405    405   #endif
   406    406   #ifndef TclpCreateTempFile
   407         -#define TclpCreateTempFile(contents) \
   408         -	(tclIntPlatStubsPtr->tclpCreateTempFile)(contents) /* 22 */
          407  +#define TclpCreateTempFile \
          408  +	(tclIntPlatStubsPtr->tclpCreateTempFile) /* 22 */
   409    409   #endif
   410    410   #ifndef TclpGetTZName
   411         -#define TclpGetTZName(isdst) \
   412         -	(tclIntPlatStubsPtr->tclpGetTZName)(isdst) /* 23 */
          411  +#define TclpGetTZName \
          412  +	(tclIntPlatStubsPtr->tclpGetTZName) /* 23 */
   413    413   #endif
   414    414   #ifndef TclWinNoBackslash
   415         -#define TclWinNoBackslash(path) \
   416         -	(tclIntPlatStubsPtr->tclWinNoBackslash)(path) /* 24 */
          415  +#define TclWinNoBackslash \
          416  +	(tclIntPlatStubsPtr->tclWinNoBackslash) /* 24 */
   417    417   #endif
   418    418   #ifndef Tcl_WinUtfToTChar
   419         -#define Tcl_WinUtfToTChar(str, len, dsPtr) \
   420         -	(tclIntPlatStubsPtr->tcl_WinUtfToTChar)(str, len, dsPtr) /* 25 */
          419  +#define Tcl_WinUtfToTChar \
          420  +	(tclIntPlatStubsPtr->tcl_WinUtfToTChar) /* 25 */
   421    421   #endif
   422    422   #ifndef Tcl_WinTCharToUtf
   423         -#define Tcl_WinTCharToUtf(str, len, dsPtr) \
   424         -	(tclIntPlatStubsPtr->tcl_WinTCharToUtf)(str, len, dsPtr) /* 26 */
          423  +#define Tcl_WinTCharToUtf \
          424  +	(tclIntPlatStubsPtr->tcl_WinTCharToUtf) /* 26 */
   425    425   #endif
   426    426   #endif /* __WIN32__ */
   427    427   #ifdef MAC_TCL
   428    428   #ifndef TclpSysAlloc
   429         -#define TclpSysAlloc(size, isBin) \
   430         -	(tclIntPlatStubsPtr->tclpSysAlloc)(size, isBin) /* 0 */
          429  +#define TclpSysAlloc \
          430  +	(tclIntPlatStubsPtr->tclpSysAlloc) /* 0 */
   431    431   #endif
   432    432   #ifndef TclpSysFree
   433         -#define TclpSysFree(ptr) \
   434         -	(tclIntPlatStubsPtr->tclpSysFree)(ptr) /* 1 */
          433  +#define TclpSysFree \
          434  +	(tclIntPlatStubsPtr->tclpSysFree) /* 1 */
   435    435   #endif
   436    436   #ifndef TclpSysRealloc
   437         -#define TclpSysRealloc(cp, size) \
   438         -	(tclIntPlatStubsPtr->tclpSysRealloc)(cp, size) /* 2 */
          437  +#define TclpSysRealloc \
          438  +	(tclIntPlatStubsPtr->tclpSysRealloc) /* 2 */
   439    439   #endif
   440    440   #ifndef TclpExit
   441         -#define TclpExit(status) \
   442         -	(tclIntPlatStubsPtr->tclpExit)(status) /* 3 */
          441  +#define TclpExit \
          442  +	(tclIntPlatStubsPtr->tclpExit) /* 3 */
   443    443   #endif
   444    444   #ifndef FSpGetDefaultDir
   445         -#define FSpGetDefaultDir(theSpec) \
   446         -	(tclIntPlatStubsPtr->fSpGetDefaultDir)(theSpec) /* 4 */
          445  +#define FSpGetDefaultDir \
          446  +	(tclIntPlatStubsPtr->fSpGetDefaultDir) /* 4 */
   447    447   #endif
   448    448   #ifndef FSpSetDefaultDir
   449         -#define FSpSetDefaultDir(theSpec) \
   450         -	(tclIntPlatStubsPtr->fSpSetDefaultDir)(theSpec) /* 5 */
          449  +#define FSpSetDefaultDir \
          450  +	(tclIntPlatStubsPtr->fSpSetDefaultDir) /* 5 */
   451    451   #endif
   452    452   #ifndef FSpFindFolder
   453         -#define FSpFindFolder(vRefNum, folderType, createFolder, spec) \
   454         -	(tclIntPlatStubsPtr->fSpFindFolder)(vRefNum, folderType, createFolder, spec) /* 6 */
          453  +#define FSpFindFolder \
          454  +	(tclIntPlatStubsPtr->fSpFindFolder) /* 6 */
   455    455   #endif
   456    456   #ifndef GetGlobalMouse
   457         -#define GetGlobalMouse(mouse) \
   458         -	(tclIntPlatStubsPtr->getGlobalMouse)(mouse) /* 7 */
          457  +#define GetGlobalMouse \
          458  +	(tclIntPlatStubsPtr->getGlobalMouse) /* 7 */
   459    459   #endif
   460    460   #ifndef FSpGetDirectoryID
   461         -#define FSpGetDirectoryID(spec, theDirID, isDirectory) \
   462         -	(tclIntPlatStubsPtr->fSpGetDirectoryID)(spec, theDirID, isDirectory) /* 8 */
          461  +#define FSpGetDirectoryID \
          462  +	(tclIntPlatStubsPtr->fSpGetDirectoryID) /* 8 */
   463    463   #endif
   464    464   #ifndef FSpOpenResFileCompat
   465         -#define FSpOpenResFileCompat(spec, permission) \
   466         -	(tclIntPlatStubsPtr->fSpOpenResFileCompat)(spec, permission) /* 9 */
          465  +#define FSpOpenResFileCompat \
          466  +	(tclIntPlatStubsPtr->fSpOpenResFileCompat) /* 9 */
   467    467   #endif
   468    468   #ifndef FSpCreateResFileCompat
   469         -#define FSpCreateResFileCompat(spec, creator, fileType, scriptTag) \
   470         -	(tclIntPlatStubsPtr->fSpCreateResFileCompat)(spec, creator, fileType, scriptTag) /* 10 */
          469  +#define FSpCreateResFileCompat \
          470  +	(tclIntPlatStubsPtr->fSpCreateResFileCompat) /* 10 */
   471    471   #endif
   472    472   #ifndef FSpLocationFromPath
   473         -#define FSpLocationFromPath(length, path, theSpec) \
   474         -	(tclIntPlatStubsPtr->fSpLocationFromPath)(length, path, theSpec) /* 11 */
          473  +#define FSpLocationFromPath \
          474  +	(tclIntPlatStubsPtr->fSpLocationFromPath) /* 11 */
   475    475   #endif
   476    476   #ifndef FSpPathFromLocation
   477         -#define FSpPathFromLocation(theSpec, length, fullPath) \
   478         -	(tclIntPlatStubsPtr->fSpPathFromLocation)(theSpec, length, fullPath) /* 12 */
          477  +#define FSpPathFromLocation \
          478  +	(tclIntPlatStubsPtr->fSpPathFromLocation) /* 12 */
   479    479   #endif
   480    480   #ifndef TclMacExitHandler
   481         -#define TclMacExitHandler() \
   482         -	(tclIntPlatStubsPtr->tclMacExitHandler)() /* 13 */
          481  +#define TclMacExitHandler \
          482  +	(tclIntPlatStubsPtr->tclMacExitHandler) /* 13 */
   483    483   #endif
   484    484   #ifndef TclMacInitExitToShell
   485         -#define TclMacInitExitToShell(usePatch) \
   486         -	(tclIntPlatStubsPtr->tclMacInitExitToShell)(usePatch) /* 14 */
          485  +#define TclMacInitExitToShell \
          486  +	(tclIntPlatStubsPtr->tclMacInitExitToShell) /* 14 */
   487    487   #endif
   488    488   #ifndef TclMacInstallExitToShellPatch
   489         -#define TclMacInstallExitToShellPatch(newProc) \
   490         -	(tclIntPlatStubsPtr->tclMacInstallExitToShellPatch)(newProc) /* 15 */
          489  +#define TclMacInstallExitToShellPatch \
          490  +	(tclIntPlatStubsPtr->tclMacInstallExitToShellPatch) /* 15 */
   491    491   #endif
   492    492   #ifndef TclMacOSErrorToPosixError
   493         -#define TclMacOSErrorToPosixError(error) \
   494         -	(tclIntPlatStubsPtr->tclMacOSErrorToPosixError)(error) /* 16 */
          493  +#define TclMacOSErrorToPosixError \
          494  +	(tclIntPlatStubsPtr->tclMacOSErrorToPosixError) /* 16 */
   495    495   #endif
   496    496   #ifndef TclMacRemoveTimer
   497         -#define TclMacRemoveTimer(timerToken) \
   498         -	(tclIntPlatStubsPtr->tclMacRemoveTimer)(timerToken) /* 17 */
          497  +#define TclMacRemoveTimer \
          498  +	(tclIntPlatStubsPtr->tclMacRemoveTimer) /* 17 */
   499    499   #endif
   500    500   #ifndef TclMacStartTimer
   501         -#define TclMacStartTimer(ms) \
   502         -	(tclIntPlatStubsPtr->tclMacStartTimer)(ms) /* 18 */
          501  +#define TclMacStartTimer \
          502  +	(tclIntPlatStubsPtr->tclMacStartTimer) /* 18 */
   503    503   #endif
   504    504   #ifndef TclMacTimerExpired
   505         -#define TclMacTimerExpired(timerToken) \
   506         -	(tclIntPlatStubsPtr->tclMacTimerExpired)(timerToken) /* 19 */
          505  +#define TclMacTimerExpired \
          506  +	(tclIntPlatStubsPtr->tclMacTimerExpired) /* 19 */
   507    507   #endif
   508    508   #ifndef TclMacRegisterResourceFork
   509         -#define TclMacRegisterResourceFork(fileRef, tokenPtr, insert) \
   510         -	(tclIntPlatStubsPtr->tclMacRegisterResourceFork)(fileRef, tokenPtr, insert) /* 20 */
          509  +#define TclMacRegisterResourceFork \
          510  +	(tclIntPlatStubsPtr->tclMacRegisterResourceFork) /* 20 */
   511    511   #endif
   512    512   #ifndef TclMacUnRegisterResourceFork
   513         -#define TclMacUnRegisterResourceFork(tokenPtr, resultPtr) \
   514         -	(tclIntPlatStubsPtr->tclMacUnRegisterResourceFork)(tokenPtr, resultPtr) /* 21 */
          513  +#define TclMacUnRegisterResourceFork \
          514  +	(tclIntPlatStubsPtr->tclMacUnRegisterResourceFork) /* 21 */
   515    515   #endif
   516    516   #ifndef TclMacCreateEnv
   517         -#define TclMacCreateEnv() \
   518         -	(tclIntPlatStubsPtr->tclMacCreateEnv)() /* 22 */
          517  +#define TclMacCreateEnv \
          518  +	(tclIntPlatStubsPtr->tclMacCreateEnv) /* 22 */
   519    519   #endif
   520    520   #ifndef TclMacFOpenHack
   521         -#define TclMacFOpenHack(path, mode) \
   522         -	(tclIntPlatStubsPtr->tclMacFOpenHack)(path, mode) /* 23 */
          521  +#define TclMacFOpenHack \
          522  +	(tclIntPlatStubsPtr->tclMacFOpenHack) /* 23 */
   523    523   #endif
   524    524   /* Slot 24 is reserved */
   525    525   #ifndef TclMacChmod
   526         -#define TclMacChmod(path, mode) \
   527         -	(tclIntPlatStubsPtr->tclMacChmod)(path, mode) /* 25 */
          526  +#define TclMacChmod \
          527  +	(tclIntPlatStubsPtr->tclMacChmod) /* 25 */
   528    528   #endif
   529    529   #endif /* MAC_TCL */
   530    530   
   531    531   #endif /* defined(USE_TCL_STUBS) && !defined(USE_TCL_STUB_PROCS) */
   532    532   
   533    533   /* !END!: Do not edit above this line. */
   534    534   
   535    535   #endif /* _TCLINTPLATDECLS */

Deleted generic/tclIntPlatStubs.c.

     1         -/* 
     2         - * tclIntPlatStubs.c --
     3         - *
     4         - *	This file contains the wrapper functions for the platform dependent
     5         - *	unsupported Tcl API.
     6         - *
     7         - * Copyright (c) 1998-1999 by Scriptics Corporation.
     8         - * All rights reserved.
     9         - *
    10         - * RCS: @(#) $Id: tclIntPlatStubs.c,v 1.3.2.5 1999/03/19 04:01:22 stanton Exp $
    11         - */
    12         -
    13         -#include "tclInt.h"
    14         -#include "tclPort.h"
    15         -
    16         -/*
    17         - * WARNING: This file is automatically generated by the tools/genStubs.tcl
    18         - * script.  Any modifications to the function declarations below should be made
    19         - * in the generic/tclInt.decls script.
    20         - */
    21         -
    22         -/* !BEGIN!: Do not edit below this line. */
    23         -
    24         -/*
    25         - * Exported stub functions:
    26         - */
    27         -
    28         -#if !defined(__WIN32__) && !defined(MAC_TCL) /* UNIX */
    29         -/* Slot 0 */
    30         -void
    31         -TclGetAndDetachPids(interp, chan)
    32         -    Tcl_Interp * interp;
    33         -    Tcl_Channel chan;
    34         -{
    35         -    (tclIntPlatStubsPtr->tclGetAndDetachPids)(interp, chan);
    36         -}
    37         -
    38         -/* Slot 1 */
    39         -int
    40         -TclpCloseFile(file)
    41         -    TclFile file;
    42         -{
    43         -    return (tclIntPlatStubsPtr->tclpCloseFile)(file);
    44         -}
    45         -
    46         -/* Slot 2 */
    47         -Tcl_Channel
    48         -TclpCreateCommandChannel(readFile, writeFile, errorFile, numPids, pidPtr)
    49         -    TclFile readFile;
    50         -    TclFile writeFile;
    51         -    TclFile errorFile;
    52         -    int numPids;
    53         -    Tcl_Pid * pidPtr;
    54         -{
    55         -    return (tclIntPlatStubsPtr->tclpCreateCommandChannel)(readFile, writeFile, errorFile, numPids, pidPtr);
    56         -}
    57         -
    58         -/* Slot 3 */
    59         -int
    60         -TclpCreatePipe(readPipe, writePipe)
    61         -    TclFile * readPipe;
    62         -    TclFile * writePipe;
    63         -{
    64         -    return (tclIntPlatStubsPtr->tclpCreatePipe)(readPipe, writePipe);
    65         -}
    66         -
    67         -/* Slot 4 */
    68         -int
    69         -TclpCreateProcess(interp, argc, argv, inputFile, outputFile, errorFile, pidPtr)
    70         -    Tcl_Interp * interp;
    71         -    int argc;
    72         -    char ** argv;
    73         -    TclFile inputFile;
    74         -    TclFile outputFile;
    75         -    TclFile errorFile;
    76         -    Tcl_Pid * pidPtr;
    77         -{
    78         -    return (tclIntPlatStubsPtr->tclpCreateProcess)(interp, argc, argv, inputFile, outputFile, errorFile, pidPtr);
    79         -}
    80         -
    81         -/* Slot 5 is reserved */
    82         -/* Slot 6 */
    83         -TclFile
    84         -TclpMakeFile(channel, direction)
    85         -    Tcl_Channel channel;
    86         -    int direction;
    87         -{
    88         -    return (tclIntPlatStubsPtr->tclpMakeFile)(channel, direction);
    89         -}
    90         -
    91         -/* Slot 7 */
    92         -TclFile
    93         -TclpOpenFile(fname, mode)
    94         -    CONST char * fname;
    95         -    int mode;
    96         -{
    97         -    return (tclIntPlatStubsPtr->tclpOpenFile)(fname, mode);
    98         -}
    99         -
   100         -/* Slot 8 */
   101         -int
   102         -TclUnixWaitForFile(fd, mask, timeout)
   103         -    int fd;
   104         -    int mask;
   105         -    int timeout;
   106         -{
   107         -    return (tclIntPlatStubsPtr->tclUnixWaitForFile)(fd, mask, timeout);
   108         -}
   109         -
   110         -/* Slot 9 */
   111         -TclFile
   112         -TclpCreateTempFile(contents)
   113         -    CONST char * contents;
   114         -{
   115         -    return (tclIntPlatStubsPtr->tclpCreateTempFile)(contents);
   116         -}
   117         -
   118         -#endif /* UNIX */
   119         -#ifdef __WIN32__
   120         -/* Slot 0 */
   121         -void
   122         -TclWinConvertError(errCode)
   123         -    DWORD errCode;
   124         -{
   125         -    (tclIntPlatStubsPtr->tclWinConvertError)(errCode);
   126         -}
   127         -
   128         -/* Slot 1 */
   129         -void
   130         -TclWinConvertWSAError(errCode)
   131         -    DWORD errCode;
   132         -{
   133         -    (tclIntPlatStubsPtr->tclWinConvertWSAError)(errCode);
   134         -}
   135         -
   136         -/* Slot 2 */
   137         -struct servent *
   138         -TclWinGetServByName(nm, proto)
   139         -    CONST char * nm;
   140         -    CONST char * proto;
   141         -{
   142         -    return (tclIntPlatStubsPtr->tclWinGetServByName)(nm, proto);
   143         -}
   144         -
   145         -/* Slot 3 */
   146         -int
   147         -TclWinGetSockOpt(s, level, optname, optval, optlen)
   148         -    SOCKET s;
   149         -    int level;
   150         -    int optname;
   151         -    char FAR * optval;
   152         -    int FAR * optlen;
   153         -{
   154         -    return (tclIntPlatStubsPtr->tclWinGetSockOpt)(s, level, optname, optval, optlen);
   155         -}
   156         -
   157         -/* Slot 4 */
   158         -HINSTANCE
   159         -TclWinGetTclInstance()
   160         -{
   161         -    return (tclIntPlatStubsPtr->tclWinGetTclInstance)();
   162         -}
   163         -
   164         -/* Slot 5 is reserved */
   165         -/* Slot 6 */
   166         -u_short
   167         -TclWinNToHS(ns)
   168         -    u_short ns;
   169         -{
   170         -    return (tclIntPlatStubsPtr->tclWinNToHS)(ns);
   171         -}
   172         -
   173         -/* Slot 7 */
   174         -int
   175         -TclWinSetSockOpt(s, level, optname, optval, optlen)
   176         -    SOCKET s;
   177         -    int level;
   178         -    int optname;
   179         -    CONST char FAR * optval;
   180         -    int optlen;
   181         -{
   182         -    return (tclIntPlatStubsPtr->tclWinSetSockOpt)(s, level, optname, optval, optlen);
   183         -}
   184         -
   185         -/* Slot 8 */
   186         -unsigned long
   187         -TclpGetPid(pid)
   188         -    Tcl_Pid pid;
   189         -{
   190         -    return (tclIntPlatStubsPtr->tclpGetPid)(pid);
   191         -}
   192         -
   193         -/* Slot 9 */
   194         -int
   195         -TclWinGetPlatformId()
   196         -{
   197         -    return (tclIntPlatStubsPtr->tclWinGetPlatformId)();
   198         -}
   199         -
   200         -/* Slot 10 */
   201         -int
   202         -TclWinSynchSpawn(args, type, trans, pidPtr)
   203         -    void * args;
   204         -    int type;
   205         -    void ** trans;
   206         -    Tcl_Pid * pidPtr;
   207         -{
   208         -    return (tclIntPlatStubsPtr->tclWinSynchSpawn)(args, type, trans, pidPtr);
   209         -}
   210         -
   211         -/* Slot 11 */
   212         -void
   213         -TclGetAndDetachPids(interp, chan)
   214         -    Tcl_Interp * interp;
   215         -    Tcl_Channel chan;
   216         -{
   217         -    (tclIntPlatStubsPtr->tclGetAndDetachPids)(interp, chan);
   218         -}
   219         -
   220         -/* Slot 12 */
   221         -int
   222         -TclpCloseFile(file)
   223         -    TclFile file;
   224         -{
   225         -    return (tclIntPlatStubsPtr->tclpCloseFile)(file);
   226         -}
   227         -
   228         -/* Slot 13 */
   229         -Tcl_Channel
   230         -TclpCreateCommandChannel(readFile, writeFile, errorFile, numPids, pidPtr)
   231         -    TclFile readFile;
   232         -    TclFile writeFile;
   233         -    TclFile errorFile;
   234         -    int numPids;
   235         -    Tcl_Pid * pidPtr;
   236         -{
   237         -    return (tclIntPlatStubsPtr->tclpCreateCommandChannel)(readFile, writeFile, errorFile, numPids, pidPtr);
   238         -}
   239         -
   240         -/* Slot 14 */
   241         -int
   242         -TclpCreatePipe(readPipe, writePipe)
   243         -    TclFile * readPipe;
   244         -    TclFile * writePipe;
   245         -{
   246         -    return (tclIntPlatStubsPtr->tclpCreatePipe)(readPipe, writePipe);
   247         -}
   248         -
   249         -/* Slot 15 */
   250         -int
   251         -TclpCreateProcess(interp, argc, argv, inputFile, outputFile, errorFile, pidPtr)
   252         -    Tcl_Interp * interp;
   253         -    int argc;
   254         -    char ** argv;
   255         -    TclFile inputFile;
   256         -    TclFile outputFile;
   257         -    TclFile errorFile;
   258         -    Tcl_Pid * pidPtr;
   259         -{
   260         -    return (tclIntPlatStubsPtr->tclpCreateProcess)(interp, argc, argv, inputFile, outputFile, errorFile, pidPtr);
   261         -}
   262         -
   263         -/* Slot 16 is reserved */
   264         -/* Slot 17 is reserved */
   265         -/* Slot 18 */
   266         -TclFile
   267         -TclpMakeFile(channel, direction)
   268         -    Tcl_Channel channel;
   269         -    int direction;
   270         -{
   271         -    return (tclIntPlatStubsPtr->tclpMakeFile)(channel, direction);
   272         -}
   273         -
   274         -/* Slot 19 */
   275         -TclFile
   276         -TclpOpenFile(fname, mode)
   277         -    CONST char * fname;
   278         -    int mode;
   279         -{
   280         -    return (tclIntPlatStubsPtr->tclpOpenFile)(fname, mode);
   281         -}
   282         -
   283         -/* Slot 20 */
   284         -void
   285         -TclWinAddProcess(hProcess, id)
   286         -    HANDLE hProcess;
   287         -    DWORD id;
   288         -{
   289         -    (tclIntPlatStubsPtr->tclWinAddProcess)(hProcess, id);
   290         -}
   291         -
   292         -/* Slot 21 */
   293         -void
   294         -TclpAsyncMark(async)
   295         -    Tcl_AsyncHandler async;
   296         -{
   297         -    (tclIntPlatStubsPtr->tclpAsyncMark)(async);
   298         -}
   299         -
   300         -/* Slot 22 */
   301         -TclFile
   302         -TclpCreateTempFile(contents)
   303         -    CONST char * contents;
   304         -{
   305         -    return (tclIntPlatStubsPtr->tclpCreateTempFile)(contents);
   306         -}
   307         -
   308         -/* Slot 23 */
   309         -char *
   310         -TclpGetTZName(isdst)
   311         -    int isdst;
   312         -{
   313         -    return (tclIntPlatStubsPtr->tclpGetTZName)(isdst);
   314         -}
   315         -
   316         -/* Slot 24 */
   317         -char *
   318         -TclWinNoBackslash(path)
   319         -    char * path;
   320         -{
   321         -    return (tclIntPlatStubsPtr->tclWinNoBackslash)(path);
   322         -}
   323         -
   324         -/* Slot 25 */
   325         -TCHAR *
   326         -Tcl_WinUtfToTChar(str, len, dsPtr)
   327         -    CONST char * str;
   328         -    int len;
   329         -    Tcl_DString * dsPtr;
   330         -{
   331         -    return (tclIntPlatStubsPtr->tcl_WinUtfToTChar)(str, len, dsPtr);
   332         -}
   333         -
   334         -/* Slot 26 */
   335         -char *
   336         -Tcl_WinTCharToUtf(str, len, dsPtr)
   337         -    CONST TCHAR * str;
   338         -    int len;
   339         -    Tcl_DString * dsPtr;
   340         -{
   341         -    return (tclIntPlatStubsPtr->tcl_WinTCharToUtf)(str, len, dsPtr);
   342         -}
   343         -
   344         -#endif /* __WIN32__ */
   345         -#ifdef MAC_TCL
   346         -/* Slot 0 */
   347         -VOID *
   348         -TclpSysAlloc(size, isBin)
   349         -    long size;
   350         -    int isBin;
   351         -{
   352         -    return (tclIntPlatStubsPtr->tclpSysAlloc)(size, isBin);
   353         -}
   354         -
   355         -/* Slot 1 */
   356         -void
   357         -TclpSysFree(ptr)
   358         -    VOID * ptr;
   359         -{
   360         -    (tclIntPlatStubsPtr->tclpSysFree)(ptr);
   361         -}
   362         -
   363         -/* Slot 2 */
   364         -VOID *
   365         -TclpSysRealloc(cp, size)
   366         -    VOID * cp;
   367         -    unsigned int size;
   368         -{
   369         -    return (tclIntPlatStubsPtr->tclpSysRealloc)(cp, size);
   370         -}
   371         -
   372         -/* Slot 3 */
   373         -void
   374         -TclpExit(status)
   375         -    int status;
   376         -{
   377         -    (tclIntPlatStubsPtr->tclpExit)(status);
   378         -}
   379         -
   380         -/* Slot 4 */
   381         -int
   382         -FSpGetDefaultDir(theSpec)
   383         -    FSSpecPtr theSpec;
   384         -{
   385         -    return (tclIntPlatStubsPtr->fSpGetDefaultDir)(theSpec);
   386         -}
   387         -
   388         -/* Slot 5 */
   389         -int
   390         -FSpSetDefaultDir(theSpec)
   391         -    FSSpecPtr theSpec;
   392         -{
   393         -    return (tclIntPlatStubsPtr->fSpSetDefaultDir)(theSpec);
   394         -}
   395         -
   396         -/* Slot 6 */
   397         -OSErr
   398         -FSpFindFolder(vRefNum, folderType, createFolder, spec)
   399         -    short vRefNum;
   400         -    OSType folderType;
   401         -    Boolean createFolder;
   402         -    FSSpec * spec;
   403         -{
   404         -    return (tclIntPlatStubsPtr->fSpFindFolder)(vRefNum, folderType, createFolder, spec);
   405         -}
   406         -
   407         -/* Slot 7 */
   408         -void
   409         -GetGlobalMouse(mouse)
   410         -    Point * mouse;
   411         -{
   412         -    (tclIntPlatStubsPtr->getGlobalMouse)(mouse);
   413         -}
   414         -
   415         -/* Slot 8 */
   416         -pascal OSErr
   417         -FSpGetDirectoryID(spec, theDirID, isDirectory)
   418         -    CONST FSSpec * spec;
   419         -    long * theDirID;
   420         -    Boolean * isDirectory;
   421         -{
   422         -    return (tclIntPlatStubsPtr->fSpGetDirectoryID)(spec, theDirID, isDirectory);
   423         -}
   424         -
   425         -/* Slot 9 */
   426         -pascal short
   427         -FSpOpenResFileCompat(spec, permission)
   428         -    CONST FSSpec * spec;
   429         -    SignedByte permission;
   430         -{
   431         -    return (tclIntPlatStubsPtr->fSpOpenResFileCompat)(spec, permission);
   432         -}
   433         -
   434         -/* Slot 10 */
   435         -pascal void
   436         -FSpCreateResFileCompat(spec, creator, fileType, scriptTag)
   437         -    CONST FSSpec * spec;
   438         -    OSType creator;
   439         -    OSType fileType;
   440         -    ScriptCode scriptTag;
   441         -{
   442         -    return (tclIntPlatStubsPtr->fSpCreateResFileCompat)(spec, creator, fileType, scriptTag);
   443         -}
   444         -
   445         -/* Slot 11 */
   446         -int
   447         -FSpLocationFromPath(length, path, theSpec)
   448         -    int length;
   449         -    CONST char * path;
   450         -    FSSpecPtr theSpec;
   451         -{
   452         -    return (tclIntPlatStubsPtr->fSpLocationFromPath)(length, path, theSpec);
   453         -}
   454         -
   455         -/* Slot 12 */
   456         -OSErr
   457         -FSpPathFromLocation(theSpec, length, fullPath)
   458         -    FSSpecPtr theSpec;
   459         -    int * length;
   460         -    Handle * fullPath;
   461         -{
   462         -    return (tclIntPlatStubsPtr->fSpPathFromLocation)(theSpec, length, fullPath);
   463         -}
   464         -
   465         -/* Slot 13 */
   466         -void
   467         -TclMacExitHandler()
   468         -{
   469         -    (tclIntPlatStubsPtr->tclMacExitHandler)();
   470         -}
   471         -
   472         -/* Slot 14 */
   473         -void
   474         -TclMacInitExitToShell(usePatch)
   475         -    int usePatch;
   476         -{
   477         -    (tclIntPlatStubsPtr->tclMacInitExitToShell)(usePatch);
   478         -}
   479         -
   480         -/* Slot 15 */
   481         -OSErr
   482         -TclMacInstallExitToShellPatch(newProc)
   483         -    ExitToShellProcPtr newProc;
   484         -{
   485         -    return (tclIntPlatStubsPtr->tclMacInstallExitToShellPatch)(newProc);
   486         -}
   487         -
   488         -/* Slot 16 */
   489         -int
   490         -TclMacOSErrorToPosixError(error)
   491         -    int error;
   492         -{
   493         -    return (tclIntPlatStubsPtr->tclMacOSErrorToPosixError)(error);
   494         -}
   495         -
   496         -/* Slot 17 */
   497         -void
   498         -TclMacRemoveTimer(timerToken)
   499         -    void * timerToken;
   500         -{
   501         -    (tclIntPlatStubsPtr->tclMacRemoveTimer)(timerToken);
   502         -}
   503         -
   504         -/* Slot 18 */
   505         -void *
   506         -TclMacStartTimer(ms)
   507         -    long ms;
   508         -{
   509         -    return (tclIntPlatStubsPtr->tclMacStartTimer)(ms);
   510         -}
   511         -
   512         -/* Slot 19 */
   513         -int
   514         -TclMacTimerExpired(timerToken)
   515         -    void * timerToken;
   516         -{
   517         -    return (tclIntPlatStubsPtr->tclMacTimerExpired)(timerToken);
   518         -}
   519         -
   520         -/* Slot 20 */
   521         -int
   522         -TclMacRegisterResourceFork(fileRef, tokenPtr, insert)
   523         -    short fileRef;
   524         -    Tcl_Obj * tokenPtr;
   525         -    int insert;
   526         -{
   527         -    return (tclIntPlatStubsPtr->tclMacRegisterResourceFork)(fileRef, tokenPtr, insert);
   528         -}
   529         -
   530         -/* Slot 21 */
   531         -short
   532         -TclMacUnRegisterResourceFork(tokenPtr, resultPtr)
   533         -    char * tokenPtr;
   534         -    Tcl_Obj * resultPtr;
   535         -{
   536         -    return (tclIntPlatStubsPtr->tclMacUnRegisterResourceFork)(tokenPtr, resultPtr);
   537         -}
   538         -
   539         -/* Slot 22 */
   540         -int
   541         -TclMacCreateEnv()
   542         -{
   543         -    return (tclIntPlatStubsPtr->tclMacCreateEnv)();
   544         -}
   545         -
   546         -/* Slot 23 */
   547         -FILE *
   548         -TclMacFOpenHack(path, mode)
   549         -    CONST char * path;
   550         -    CONST char * mode;
   551         -{
   552         -    return (tclIntPlatStubsPtr->tclMacFOpenHack)(path, mode);
   553         -}
   554         -
   555         -/* Slot 24 is reserved */
   556         -/* Slot 25 */
   557         -int
   558         -TclMacChmod(path, mode)
   559         -    char * path;
   560         -    int mode;
   561         -{
   562         -    return (tclIntPlatStubsPtr->tclMacChmod)(path, mode);
   563         -}
   564         -
   565         -#endif /* MAC_TCL */
   566         -
   567         -/* !END!: Do not edit above this line. */

Deleted generic/tclIntStubs.c.

     1         -/* 
     2         - * tclIntStubs.c --
     3         - *
     4         - *	This file contains the wrapper functions for the platform independent
     5         - *	unsupported Tcl API.
     6         - *
     7         - * Copyright (c) 1998-1999 by Scriptics Corporation.
     8         - * All rights reserved.
     9         - *
    10         - * RCS: @(#) $Id: tclIntStubs.c,v 1.3.2.5 1999/03/19 04:01:22 stanton Exp $
    11         - */
    12         -
    13         -#include "tclInt.h"
    14         -
    15         -/*
    16         - * WARNING: This file is automatically generated by the tools/genStubs.tcl
    17         - * script.  Any modifications to the function declarations below should be made
    18         - * in the generic/tclInt.decls script.
    19         - */
    20         -
    21         -/* !BEGIN!: Do not edit below this line. */
    22         -
    23         -/*
    24         - * Exported stub functions:
    25         - */
    26         -
    27         -/* Slot 0 */
    28         -int
    29         -TclAccess(path, mode)
    30         -    CONST char * path;
    31         -    int mode;
    32         -{
    33         -    return (tclIntStubsPtr->tclAccess)(path, mode);
    34         -}
    35         -
    36         -/* Slot 1 */
    37         -int
    38         -TclAccessDeleteProc(proc)
    39         -    TclAccessProc_ * proc;
    40         -{
    41         -    return (tclIntStubsPtr->tclAccessDeleteProc)(proc);
    42         -}
    43         -
    44         -/* Slot 2 */
    45         -int
    46         -TclAccessInsertProc(proc)
    47         -    TclAccessProc_ * proc;
    48         -{
    49         -    return (tclIntStubsPtr->tclAccessInsertProc)(proc);
    50         -}
    51         -
    52         -/* Slot 3 */
    53         -void
    54         -TclAllocateFreeObjects()
    55         -{
    56         -    (tclIntStubsPtr->tclAllocateFreeObjects)();
    57         -}
    58         -
    59         -/* Slot 4 is reserved */
    60         -/* Slot 5 */
    61         -int
    62         -TclCleanupChildren(interp, numPids, pidPtr, errorChan)
    63         -    Tcl_Interp * interp;
    64         -    int numPids;
    65         -    Tcl_Pid * pidPtr;
    66         -    Tcl_Channel errorChan;
    67         -{
    68         -    return (tclIntStubsPtr->tclCleanupChildren)(interp, numPids, pidPtr, errorChan);
    69         -}
    70         -
    71         -/* Slot 6 */
    72         -void
    73         -TclCleanupCommand(cmdPtr)
    74         -    Command * cmdPtr;
    75         -{
    76         -    (tclIntStubsPtr->tclCleanupCommand)(cmdPtr);
    77         -}
    78         -
    79         -/* Slot 7 */
    80         -int
    81         -TclCopyAndCollapse(count, src, dst)
    82         -    int count;
    83         -    CONST char * src;
    84         -    char * dst;
    85         -{
    86         -    return (tclIntStubsPtr->tclCopyAndCollapse)(count, src, dst);
    87         -}
    88         -
    89         -/* Slot 8 */
    90         -int
    91         -TclCopyChannel(interp, inChan, outChan, toRead, cmdPtr)
    92         -    Tcl_Interp * interp;
    93         -    Tcl_Channel inChan;
    94         -    Tcl_Channel outChan;
    95         -    int toRead;
    96         -    Tcl_Obj * cmdPtr;
    97         -{
    98         -    return (tclIntStubsPtr->tclCopyChannel)(interp, inChan, outChan, toRead, cmdPtr);
    99         -}
   100         -
   101         -/* Slot 9 */
   102         -int
   103         -TclCreatePipeline(interp, argc, argv, pidArrayPtr, inPipePtr, outPipePtr, errFilePtr)
   104         -    Tcl_Interp * interp;
   105         -    int argc;
   106         -    char ** argv;
   107         -    Tcl_Pid ** pidArrayPtr;
   108         -    TclFile * inPipePtr;
   109         -    TclFile * outPipePtr;
   110         -    TclFile * errFilePtr;
   111         -{
   112         -    return (tclIntStubsPtr->tclCreatePipeline)(interp, argc, argv, pidArrayPtr, inPipePtr, outPipePtr, errFilePtr);
   113         -}
   114         -
   115         -/* Slot 10 */
   116         -int
   117         -TclCreateProc(interp, nsPtr, procName, argsPtr, bodyPtr, procPtrPtr)
   118         -    Tcl_Interp * interp;
   119         -    Namespace * nsPtr;
   120         -    char * procName;
   121         -    Tcl_Obj * argsPtr;
   122         -    Tcl_Obj * bodyPtr;
   123         -    Proc ** procPtrPtr;
   124         -{
   125         -    return (tclIntStubsPtr->tclCreateProc)(interp, nsPtr, procName, argsPtr, bodyPtr, procPtrPtr);
   126         -}
   127         -
   128         -/* Slot 11 */
   129         -void
   130         -TclDeleteCompiledLocalVars(iPtr, framePtr)
   131         -    Interp * iPtr;
   132         -    CallFrame * framePtr;
   133         -{
   134         -    (tclIntStubsPtr->tclDeleteCompiledLocalVars)(iPtr, framePtr);
   135         -}
   136         -
   137         -/* Slot 12 */
   138         -void
   139         -TclDeleteVars(iPtr, tablePtr)
   140         -    Interp * iPtr;
   141         -    Tcl_HashTable * tablePtr;
   142         -{
   143         -    (tclIntStubsPtr->tclDeleteVars)(iPtr, tablePtr);
   144         -}
   145         -
   146         -/* Slot 13 */
   147         -int
   148         -TclDoGlob(interp, separators, headPtr, tail)
   149         -    Tcl_Interp * interp;
   150         -    char * separators;
   151         -    Tcl_DString * headPtr;
   152         -    char * tail;
   153         -{
   154         -    return (tclIntStubsPtr->tclDoGlob)(interp, separators, headPtr, tail);
   155         -}
   156         -
   157         -/* Slot 14 */
   158         -void
   159         -TclDumpMemoryInfo(outFile)
   160         -    FILE * outFile;
   161         -{
   162         -    (tclIntStubsPtr->tclDumpMemoryInfo)(outFile);
   163         -}
   164         -
   165         -/* Slot 15 is reserved */
   166         -/* Slot 16 */
   167         -void
   168         -TclExprFloatError(interp, value)
   169         -    Tcl_Interp * interp;
   170         -    double value;
   171         -{
   172         -    (tclIntStubsPtr->tclExprFloatError)(interp, value);
   173         -}
   174         -
   175         -/* Slot 17 */
   176         -int
   177         -TclFileAttrsCmd(interp, objc, objv)
   178         -    Tcl_Interp * interp;
   179         -    int objc;
   180         -    Tcl_Obj *CONST objv[];
   181         -{
   182         -    return (tclIntStubsPtr->tclFileAttrsCmd)(interp, objc, objv);
   183         -}
   184         -
   185         -/* Slot 18 */
   186         -int
   187         -TclFileCopyCmd(interp, argc, argv)
   188         -    Tcl_Interp * interp;
   189         -    int argc;
   190         -    char ** argv;
   191         -{
   192         -    return (tclIntStubsPtr->tclFileCopyCmd)(interp, argc, argv);
   193         -}
   194         -
   195         -/* Slot 19 */
   196         -int
   197         -TclFileDeleteCmd(interp, argc, argv)
   198         -    Tcl_Interp * interp;
   199         -    int argc;
   200         -    char ** argv;
   201         -{
   202         -    return (tclIntStubsPtr->tclFileDeleteCmd)(interp, argc, argv);
   203         -}
   204         -
   205         -/* Slot 20 */
   206         -int
   207         -TclFileMakeDirsCmd(interp, argc, argv)
   208         -    Tcl_Interp * interp;
   209         -    int argc;
   210         -    char ** argv;
   211         -{
   212         -    return (tclIntStubsPtr->tclFileMakeDirsCmd)(interp, argc, argv);
   213         -}
   214         -
   215         -/* Slot 21 */
   216         -int
   217         -TclFileRenameCmd(interp, argc, argv)
   218         -    Tcl_Interp * interp;
   219         -    int argc;
   220         -    char ** argv;
   221         -{
   222         -    return (tclIntStubsPtr->tclFileRenameCmd)(interp, argc, argv);
   223         -}
   224         -
   225         -/* Slot 22 */
   226         -int
   227         -TclFindElement(interp, listStr, listLength, elementPtr, nextPtr, sizePtr, bracePtr)
   228         -    Tcl_Interp * interp;
   229         -    CONST char * listStr;
   230         -    int listLength;
   231         -    CONST char ** elementPtr;
   232         -    CONST char ** nextPtr;
   233         -    int * sizePtr;
   234         -    int * bracePtr;
   235         -{
   236         -    return (tclIntStubsPtr->tclFindElement)(interp, listStr, listLength, elementPtr, nextPtr, sizePtr, bracePtr);
   237         -}
   238         -
   239         -/* Slot 23 */
   240         -Proc *
   241         -TclFindProc(iPtr, procName)
   242         -    Interp * iPtr;
   243         -    char * procName;
   244         -{
   245         -    return (tclIntStubsPtr->tclFindProc)(iPtr, procName);
   246         -}
   247         -
   248         -/* Slot 24 */
   249         -int
   250         -TclFormatInt(buffer, n)
   251         -    char * buffer;
   252         -    long n;
   253         -{
   254         -    return (tclIntStubsPtr->tclFormatInt)(buffer, n);
   255         -}
   256         -
   257         -/* Slot 25 */
   258         -void
   259         -TclFreePackageInfo(iPtr)
   260         -    Interp * iPtr;
   261         -{
   262         -    (tclIntStubsPtr->tclFreePackageInfo)(iPtr);
   263         -}
   264         -
   265         -/* Slot 26 is reserved */
   266         -/* Slot 27 */
   267         -int
   268         -TclGetDate(p, now, zone, timePtr)
   269         -    char * p;
   270         -    unsigned long now;
   271         -    long zone;
   272         -    unsigned long * timePtr;
   273         -{
   274         -    return (tclIntStubsPtr->tclGetDate)(p, now, zone, timePtr);
   275         -}
   276         -
   277         -/* Slot 28 */
   278         -Tcl_Channel
   279         -TclpGetDefaultStdChannel(type)
   280         -    int type;
   281         -{
   282         -    return (tclIntStubsPtr->tclpGetDefaultStdChannel)(type);
   283         -}
   284         -
   285         -/* Slot 29 */
   286         -Tcl_Obj *
   287         -TclGetElementOfIndexedArray(interp, localIndex, elemPtr, leaveErrorMsg)
   288         -    Tcl_Interp * interp;
   289         -    int localIndex;
   290         -    Tcl_Obj * elemPtr;
   291         -    int leaveErrorMsg;
   292         -{
   293         -    return (tclIntStubsPtr->tclGetElementOfIndexedArray)(interp, localIndex, elemPtr, leaveErrorMsg);
   294         -}
   295         -
   296         -/* Slot 30 is reserved */
   297         -/* Slot 31 */
   298         -char *
   299         -TclGetExtension(name)
   300         -    char * name;
   301         -{
   302         -    return (tclIntStubsPtr->tclGetExtension)(name);
   303         -}
   304         -
   305         -/* Slot 32 */
   306         -int
   307         -TclGetFrame(interp, str, framePtrPtr)
   308         -    Tcl_Interp * interp;
   309         -    char * str;
   310         -    CallFrame ** framePtrPtr;
   311         -{
   312         -    return (tclIntStubsPtr->tclGetFrame)(interp, str, framePtrPtr);
   313         -}
   314         -
   315         -/* Slot 33 */
   316         -TclCmdProcType
   317         -TclGetInterpProc()
   318         -{
   319         -    return (tclIntStubsPtr->tclGetInterpProc)();
   320         -}
   321         -
   322         -/* Slot 34 */
   323         -int
   324         -TclGetIntForIndex(interp, objPtr, endValue, indexPtr)
   325         -    Tcl_Interp * interp;
   326         -    Tcl_Obj * objPtr;
   327         -    int endValue;
   328         -    int * indexPtr;
   329         -{
   330         -    return (tclIntStubsPtr->tclGetIntForIndex)(interp, objPtr, endValue, indexPtr);
   331         -}
   332         -
   333         -/* Slot 35 */
   334         -Tcl_Obj *
   335         -TclGetIndexedScalar(interp, localIndex, leaveErrorMsg)
   336         -    Tcl_Interp * interp;
   337         -    int localIndex;
   338         -    int leaveErrorMsg;
   339         -{
   340         -    return (tclIntStubsPtr->tclGetIndexedScalar)(interp, localIndex, leaveErrorMsg);
   341         -}
   342         -
   343         -/* Slot 36 */
   344         -int
   345         -TclGetLong(interp, str, longPtr)
   346         -    Tcl_Interp * interp;
   347         -    char * str;
   348         -    long * longPtr;
   349         -{
   350         -    return (tclIntStubsPtr->tclGetLong)(interp, str, longPtr);
   351         -}
   352         -
   353         -/* Slot 37 */
   354         -int
   355         -TclGetLoadedPackages(interp, targetName)
   356         -    Tcl_Interp * interp;
   357         -    char * targetName;
   358         -{
   359         -    return (tclIntStubsPtr->tclGetLoadedPackages)(interp, targetName);
   360         -}
   361         -
   362         -/* Slot 38 */
   363         -int
   364         -TclGetNamespaceForQualName(interp, qualName, cxtNsPtr, flags, nsPtrPtr, altNsPtrPtr, actualCxtPtrPtr, simpleNamePtr)
   365         -    Tcl_Interp * interp;
   366         -    char * qualName;
   367         -    Namespace * cxtNsPtr;
   368         -    int flags;
   369         -    Namespace ** nsPtrPtr;
   370         -    Namespace ** altNsPtrPtr;
   371         -    Namespace ** actualCxtPtrPtr;
   372         -    char ** simpleNamePtr;
   373         -{
   374         -    return (tclIntStubsPtr->tclGetNamespaceForQualName)(interp, qualName, cxtNsPtr, flags, nsPtrPtr, altNsPtrPtr, actualCxtPtrPtr, simpleNamePtr);
   375         -}
   376         -
   377         -/* Slot 39 */
   378         -TclObjCmdProcType
   379         -TclGetObjInterpProc()
   380         -{
   381         -    return (tclIntStubsPtr->tclGetObjInterpProc)();
   382         -}
   383         -
   384         -/* Slot 40 */
   385         -int
   386         -TclGetOpenMode(interp, str, seekFlagPtr)
   387         -    Tcl_Interp * interp;
   388         -    char * str;
   389         -    int * seekFlagPtr;
   390         -{
   391         -    return (tclIntStubsPtr->tclGetOpenMode)(interp, str, seekFlagPtr);
   392         -}
   393         -
   394         -/* Slot 41 */
   395         -Tcl_Command
   396         -TclGetOriginalCommand(command)
   397         -    Tcl_Command command;
   398         -{
   399         -    return (tclIntStubsPtr->tclGetOriginalCommand)(command);
   400         -}
   401         -
   402         -/* Slot 42 */
   403         -char *
   404         -TclpGetUserHome(name, bufferPtr)
   405         -    CONST char * name;
   406         -    Tcl_DString * bufferPtr;
   407         -{
   408         -    return (tclIntStubsPtr->tclpGetUserHome)(name, bufferPtr);
   409         -}
   410         -
   411         -/* Slot 43 */
   412         -int
   413         -TclGlobalInvoke(interp, argc, argv, flags)
   414         -    Tcl_Interp * interp;
   415         -    int argc;
   416         -    char ** argv;
   417         -    int flags;
   418         -{
   419         -    return (tclIntStubsPtr->tclGlobalInvoke)(interp, argc, argv, flags);
   420         -}
   421         -
   422         -/* Slot 44 */
   423         -int
   424         -TclGuessPackageName(fileName, bufPtr)
   425         -    char * fileName;
   426         -    Tcl_DString * bufPtr;
   427         -{
   428         -    return (tclIntStubsPtr->tclGuessPackageName)(fileName, bufPtr);
   429         -}
   430         -
   431         -/* Slot 45 */
   432         -int
   433         -TclHideUnsafeCommands(interp)
   434         -    Tcl_Interp * interp;
   435         -{
   436         -    return (tclIntStubsPtr->tclHideUnsafeCommands)(interp);
   437         -}
   438         -
   439         -/* Slot 46 */
   440         -int
   441         -TclInExit()
   442         -{
   443         -    return (tclIntStubsPtr->tclInExit)();
   444         -}
   445         -
   446         -/* Slot 47 */
   447         -Tcl_Obj *
   448         -TclIncrElementOfIndexedArray(interp, localIndex, elemPtr, incrAmount)
   449         -    Tcl_Interp * interp;
   450         -    int localIndex;
   451         -    Tcl_Obj * elemPtr;
   452         -    long incrAmount;
   453         -{
   454         -    return (tclIntStubsPtr->tclIncrElementOfIndexedArray)(interp, localIndex, elemPtr, incrAmount);
   455         -}
   456         -
   457         -/* Slot 48 */
   458         -Tcl_Obj *
   459         -TclIncrIndexedScalar(interp, localIndex, incrAmount)
   460         -    Tcl_Interp * interp;
   461         -    int localIndex;
   462         -    long incrAmount;
   463         -{
   464         -    return (tclIntStubsPtr->tclIncrIndexedScalar)(interp, localIndex, incrAmount);
   465         -}
   466         -
   467         -/* Slot 49 */
   468         -Tcl_Obj *
   469         -TclIncrVar2(interp, part1Ptr, part2Ptr, incrAmount, part1NotParsed)
   470         -    Tcl_Interp * interp;
   471         -    Tcl_Obj * part1Ptr;
   472         -    Tcl_Obj * part2Ptr;
   473         -    long incrAmount;
   474         -    int part1NotParsed;
   475         -{
   476         -    return (tclIntStubsPtr->tclIncrVar2)(interp, part1Ptr, part2Ptr, incrAmount, part1NotParsed);
   477         -}
   478         -
   479         -/* Slot 50 */
   480         -void
   481         -TclInitCompiledLocals(interp, framePtr, nsPtr)
   482         -    Tcl_Interp * interp;
   483         -    CallFrame * framePtr;
   484         -    Namespace * nsPtr;
   485         -{
   486         -    (tclIntStubsPtr->tclInitCompiledLocals)(interp, framePtr, nsPtr);
   487         -}
   488         -
   489         -/* Slot 51 */
   490         -int
   491         -TclInterpInit(interp)
   492         -    Tcl_Interp * interp;
   493         -{
   494         -    return (tclIntStubsPtr->tclInterpInit)(interp);
   495         -}
   496         -
   497         -/* Slot 52 */
   498         -int
   499         -TclInvoke(interp, argc, argv, flags)
   500         -    Tcl_Interp * interp;
   501         -    int argc;
   502         -    char ** argv;
   503         -    int flags;
   504         -{
   505         -    return (tclIntStubsPtr->tclInvoke)(interp, argc, argv, flags);
   506         -}
   507         -
   508         -/* Slot 53 */
   509         -int
   510         -TclInvokeObjectCommand(clientData, interp, argc, argv)
   511         -    ClientData clientData;
   512         -    Tcl_Interp * interp;
   513         -    int argc;
   514         -    char ** argv;
   515         -{
   516         -    return (tclIntStubsPtr->tclInvokeObjectCommand)(clientData, interp, argc, argv);
   517         -}
   518         -
   519         -/* Slot 54 */
   520         -int
   521         -TclInvokeStringCommand(clientData, interp, objc, objv)
   522         -    ClientData clientData;
   523         -    Tcl_Interp * interp;
   524         -    int objc;
   525         -    Tcl_Obj *CONST objv[];
   526         -{
   527         -    return (tclIntStubsPtr->tclInvokeStringCommand)(clientData, interp, objc, objv);
   528         -}
   529         -
   530         -/* Slot 55 */
   531         -Proc *
   532         -TclIsProc(cmdPtr)
   533         -    Command * cmdPtr;
   534         -{
   535         -    return (tclIntStubsPtr->tclIsProc)(cmdPtr);
   536         -}
   537         -
   538         -/* Slot 56 is reserved */
   539         -/* Slot 57 is reserved */
   540         -/* Slot 58 */
   541         -Var *
   542         -TclLookupVar(interp, part1, part2, flags, msg, createPart1, createPart2, arrayPtrPtr)
   543         -    Tcl_Interp * interp;
   544         -    char * part1;
   545         -    char * part2;
   546         -    int flags;
   547         -    char * msg;
   548         -    int createPart1;
   549         -    int createPart2;
   550         -    Var ** arrayPtrPtr;
   551         -{
   552         -    return (tclIntStubsPtr->tclLookupVar)(interp, part1, part2, flags, msg, createPart1, createPart2, arrayPtrPtr);
   553         -}
   554         -
   555         -/* Slot 59 */
   556         -int
   557         -TclpMatchFiles(interp, separators, dirPtr, pattern, tail)
   558         -    Tcl_Interp * interp;
   559         -    char * separators;
   560         -    Tcl_DString * dirPtr;
   561         -    char * pattern;
   562         -    char * tail;
   563         -{
   564         -    return (tclIntStubsPtr->tclpMatchFiles)(interp, separators, dirPtr, pattern, tail);
   565         -}
   566         -
   567         -/* Slot 60 */
   568         -int
   569         -TclNeedSpace(start, end)
   570         -    char * start;
   571         -    char * end;
   572         -{
   573         -    return (tclIntStubsPtr->tclNeedSpace)(start, end);
   574         -}
   575         -
   576         -/* Slot 61 */
   577         -Tcl_Obj *
   578         -TclNewProcBodyObj(procPtr)
   579         -    Proc * procPtr;
   580         -{
   581         -    return (tclIntStubsPtr->tclNewProcBodyObj)(procPtr);
   582         -}
   583         -
   584         -/* Slot 62 */
   585         -int
   586         -TclObjCommandComplete(cmdPtr)
   587         -    Tcl_Obj * cmdPtr;
   588         -{
   589         -    return (tclIntStubsPtr->tclObjCommandComplete)(cmdPtr);
   590         -}
   591         -
   592         -/* Slot 63 */
   593         -int
   594         -TclObjInterpProc(clientData, interp, objc, objv)
   595         -    ClientData clientData;
   596         -    Tcl_Interp * interp;
   597         -    int objc;
   598         -    Tcl_Obj *CONST objv[];
   599         -{
   600         -    return (tclIntStubsPtr->tclObjInterpProc)(clientData, interp, objc, objv);
   601         -}
   602         -
   603         -/* Slot 64 */
   604         -int
   605         -TclObjInvoke(interp, objc, objv, flags)
   606         -    Tcl_Interp * interp;
   607         -    int objc;
   608         -    Tcl_Obj *CONST objv[];
   609         -    int flags;
   610         -{
   611         -    return (tclIntStubsPtr->tclObjInvoke)(interp, objc, objv, flags);
   612         -}
   613         -
   614         -/* Slot 65 */
   615         -int
   616         -TclObjInvokeGlobal(interp, objc, objv, flags)
   617         -    Tcl_Interp * interp;
   618         -    int objc;
   619         -    Tcl_Obj *CONST objv[];
   620         -    int flags;
   621         -{
   622         -    return (tclIntStubsPtr->tclObjInvokeGlobal)(interp, objc, objv, flags);
   623         -}
   624         -
   625         -/* Slot 66 */
   626         -int
   627         -TclOpenFileChannelDeleteProc(proc)
   628         -    TclOpenFileChannelProc_ * proc;
   629         -{
   630         -    return (tclIntStubsPtr->tclOpenFileChannelDeleteProc)(proc);
   631         -}
   632         -
   633         -/* Slot 67 */
   634         -int
   635         -TclOpenFileChannelInsertProc(proc)
   636         -    TclOpenFileChannelProc_ * proc;
   637         -{
   638         -    return (tclIntStubsPtr->tclOpenFileChannelInsertProc)(proc);
   639         -}
   640         -
   641         -/* Slot 68 */
   642         -int
   643         -TclpAccess(path, mode)
   644         -    CONST char * path;
   645         -    int mode;
   646         -{
   647         -    return (tclIntStubsPtr->tclpAccess)(path, mode);
   648         -}
   649         -
   650         -/* Slot 69 */
   651         -char *
   652         -TclpAlloc(size)
   653         -    unsigned int size;
   654         -{
   655         -    return (tclIntStubsPtr->tclpAlloc)(size);
   656         -}
   657         -
   658         -/* Slot 70 */
   659         -int
   660         -TclpCopyFile(source, dest)
   661         -    CONST char * source;
   662         -    CONST char * dest;
   663         -{
   664         -    return (tclIntStubsPtr->tclpCopyFile)(source, dest);
   665         -}
   666         -
   667         -/* Slot 71 */
   668         -int
   669         -TclpCopyDirectory(source, dest, errorPtr)
   670         -    CONST char * source;
   671         -    CONST char * dest;
   672         -    Tcl_DString * errorPtr;
   673         -{
   674         -    return (tclIntStubsPtr->tclpCopyDirectory)(source, dest, errorPtr);
   675         -}
   676         -
   677         -/* Slot 72 */
   678         -int
   679         -TclpCreateDirectory(path)
   680         -    CONST char * path;
   681         -{
   682         -    return (tclIntStubsPtr->tclpCreateDirectory)(path);
   683         -}
   684         -
   685         -/* Slot 73 */
   686         -int
   687         -TclpDeleteFile(path)
   688         -    CONST char * path;
   689         -{
   690         -    return (tclIntStubsPtr->tclpDeleteFile)(path);
   691         -}
   692         -
   693         -/* Slot 74 */
   694         -void
   695         -TclpFree(ptr)
   696         -    char * ptr;
   697         -{
   698         -    (tclIntStubsPtr->tclpFree)(ptr);
   699         -}
   700         -
   701         -/* Slot 75 */
   702         -unsigned long
   703         -TclpGetClicks()
   704         -{
   705         -    return (tclIntStubsPtr->tclpGetClicks)();
   706         -}
   707         -
   708         -/* Slot 76 */
   709         -unsigned long
   710         -TclpGetSeconds()
   711         -{
   712         -    return (tclIntStubsPtr->tclpGetSeconds)();
   713         -}
   714         -
   715         -/* Slot 77 */
   716         -void
   717         -TclpGetTime(time)
   718         -    Tcl_Time * time;
   719         -{
   720         -    (tclIntStubsPtr->tclpGetTime)(time);
   721         -}
   722         -
   723         -/* Slot 78 */
   724         -int
   725         -TclpGetTimeZone(time)
   726         -    unsigned long time;
   727         -{
   728         -    return (tclIntStubsPtr->tclpGetTimeZone)(time);
   729         -}
   730         -
   731         -/* Slot 79 */
   732         -int
   733         -TclpListVolumes(interp)
   734         -    Tcl_Interp * interp;
   735         -{
   736         -    return (tclIntStubsPtr->tclpListVolumes)(interp);
   737         -}
   738         -
   739         -/* Slot 80 */
   740         -Tcl_Channel
   741         -TclpOpenFileChannel(interp, fileName, modeString, permissions)
   742         -    Tcl_Interp * interp;
   743         -    char * fileName;
   744         -    char * modeString;
   745         -    int permissions;
   746         -{
   747         -    return (tclIntStubsPtr->tclpOpenFileChannel)(interp, fileName, modeString, permissions);
   748         -}
   749         -
   750         -/* Slot 81 */
   751         -char *
   752         -TclpRealloc(ptr, size)
   753         -    char * ptr;
   754         -    unsigned int size;
   755         -{
   756         -    return (tclIntStubsPtr->tclpRealloc)(ptr, size);
   757         -}
   758         -
   759         -/* Slot 82 */
   760         -int
   761         -TclpRemoveDirectory(path, recursive, errorPtr)
   762         -    CONST char * path;
   763         -    int recursive;
   764         -    Tcl_DString * errorPtr;
   765         -{
   766         -    return (tclIntStubsPtr->tclpRemoveDirectory)(path, recursive, errorPtr);
   767         -}
   768         -
   769         -/* Slot 83 */
   770         -int
   771         -TclpRenameFile(source, dest)
   772         -    CONST char * source;
   773         -    CONST char * dest;
   774         -{
   775         -    return (tclIntStubsPtr->tclpRenameFile)(source, dest);
   776         -}
   777         -
   778         -/* Slot 84 is reserved */
   779         -/* Slot 85 is reserved */
   780         -/* Slot 86 is reserved */
   781         -/* Slot 87 is reserved */
   782         -/* Slot 88 */
   783         -char *
   784         -TclPrecTraceProc(clientData, interp, name1, name2, flags)
   785         -    ClientData clientData;
   786         -    Tcl_Interp * interp;
   787         -    char * name1;
   788         -    char * name2;
   789         -    int flags;
   790         -{
   791         -    return (tclIntStubsPtr->tclPrecTraceProc)(clientData, interp, name1, name2, flags);
   792         -}
   793         -
   794         -/* Slot 89 */
   795         -int
   796         -TclPreventAliasLoop(interp, cmdInterp, cmd)
   797         -    Tcl_Interp * interp;
   798         -    Tcl_Interp * cmdInterp;
   799         -    Tcl_Command cmd;
   800         -{
   801         -    return (tclIntStubsPtr->tclPreventAliasLoop)(interp, cmdInterp, cmd);
   802         -}
   803         -
   804         -/* Slot 90 is reserved */
   805         -/* Slot 91 */
   806         -void
   807         -TclProcCleanupProc(procPtr)
   808         -    Proc * procPtr;
   809         -{
   810         -    (tclIntStubsPtr->tclProcCleanupProc)(procPtr);
   811         -}
   812         -
   813         -/* Slot 92 */
   814         -int
   815         -TclProcCompileProc(interp, procPtr, bodyPtr, nsPtr, description, procName)
   816         -    Tcl_Interp * interp;
   817         -    Proc * procPtr;
   818         -    Tcl_Obj * bodyPtr;
   819         -    Namespace * nsPtr;
   820         -    CONST char * description;
   821         -    CONST char * procName;
   822         -{
   823         -    return (tclIntStubsPtr->tclProcCompileProc)(interp, procPtr, bodyPtr, nsPtr, description, procName);
   824         -}
   825         -
   826         -/* Slot 93 */
   827         -void
   828         -TclProcDeleteProc(clientData)
   829         -    ClientData clientData;
   830         -{
   831         -    (tclIntStubsPtr->tclProcDeleteProc)(clientData);
   832         -}
   833         -
   834         -/* Slot 94 */
   835         -int
   836         -TclProcInterpProc(clientData, interp, argc, argv)
   837         -    ClientData clientData;
   838         -    Tcl_Interp * interp;
   839         -    int argc;
   840         -    char ** argv;
   841         -{
   842         -    return (tclIntStubsPtr->tclProcInterpProc)(clientData, interp, argc, argv);
   843         -}
   844         -
   845         -/* Slot 95 */
   846         -int
   847         -TclpStat(path, buf)
   848         -    CONST char * path;
   849         -    struct stat * buf;
   850         -{
   851         -    return (tclIntStubsPtr->tclpStat)(path, buf);
   852         -}
   853         -
   854         -/* Slot 96 */
   855         -int
   856         -TclRenameCommand(interp, oldName, newName)
   857         -    Tcl_Interp * interp;
   858         -    char * oldName;
   859         -    char * newName;
   860         -{
   861         -    return (tclIntStubsPtr->tclRenameCommand)(interp, oldName, newName);
   862         -}
   863         -
   864         -/* Slot 97 */
   865         -void
   866         -TclResetShadowedCmdRefs(interp, newCmdPtr)
   867         -    Tcl_Interp * interp;
   868         -    Command * newCmdPtr;
   869         -{
   870         -    (tclIntStubsPtr->tclResetShadowedCmdRefs)(interp, newCmdPtr);
   871         -}
   872         -
   873         -/* Slot 98 */
   874         -int
   875         -TclServiceIdle()
   876         -{
   877         -    return (tclIntStubsPtr->tclServiceIdle)();
   878         -}
   879         -
   880         -/* Slot 99 */
   881         -Tcl_Obj *
   882         -TclSetElementOfIndexedArray(interp, localIndex, elemPtr, objPtr, leaveErrorMsg)
   883         -    Tcl_Interp * interp;
   884         -    int localIndex;
   885         -    Tcl_Obj * elemPtr;
   886         -    Tcl_Obj * objPtr;
   887         -    int leaveErrorMsg;
   888         -{
   889         -    return (tclIntStubsPtr->tclSetElementOfIndexedArray)(interp, localIndex, elemPtr, objPtr, leaveErrorMsg);
   890         -}
   891         -
   892         -/* Slot 100 */
   893         -Tcl_Obj *
   894         -TclSetIndexedScalar(interp, localIndex, objPtr, leaveErrorMsg)
   895         -    Tcl_Interp * interp;
   896         -    int localIndex;
   897         -    Tcl_Obj * objPtr;
   898         -    int leaveErrorMsg;
   899         -{
   900         -    return (tclIntStubsPtr->tclSetIndexedScalar)(interp, localIndex, objPtr, leaveErrorMsg);
   901         -}
   902         -
   903         -/* Slot 101 is reserved */
   904         -/* Slot 102 */
   905         -void
   906         -TclSetupEnv(interp)
   907         -    Tcl_Interp * interp;
   908         -{
   909         -    (tclIntStubsPtr->tclSetupEnv)(interp);
   910         -}
   911         -
   912         -/* Slot 103 */
   913         -int
   914         -TclSockGetPort(interp, str, proto, portPtr)
   915         -    Tcl_Interp * interp;
   916         -    char * str;
   917         -    char * proto;
   918         -    int * portPtr;
   919         -{
   920         -    return (tclIntStubsPtr->tclSockGetPort)(interp, str, proto, portPtr);
   921         -}
   922         -
   923         -/* Slot 104 */
   924         -int
   925         -TclSockMinimumBuffers(sock, size)
   926         -    int sock;
   927         -    int size;
   928         -{
   929         -    return (tclIntStubsPtr->tclSockMinimumBuffers)(sock, size);
   930         -}
   931         -
   932         -/* Slot 105 */
   933         -int
   934         -TclStat(path, buf)
   935         -    CONST char * path;
   936         -    TclStat_ * buf;
   937         -{
   938         -    return (tclIntStubsPtr->tclStat)(path, buf);
   939         -}
   940         -
   941         -/* Slot 106 */
   942         -int
   943         -TclStatDeleteProc(proc)
   944         -    TclStatProc_ * proc;
   945         -{
   946         -    return (tclIntStubsPtr->tclStatDeleteProc)(proc);
   947         -}
   948         -
   949         -/* Slot 107 */
   950         -int
   951         -TclStatInsertProc(proc)
   952         -    TclStatProc_ * proc;
   953         -{
   954         -    return (tclIntStubsPtr->tclStatInsertProc)(proc);
   955         -}
   956         -
   957         -/* Slot 108 */
   958         -void
   959         -TclTeardownNamespace(nsPtr)
   960         -    Namespace * nsPtr;
   961         -{
   962         -    (tclIntStubsPtr->tclTeardownNamespace)(nsPtr);
   963         -}
   964         -
   965         -/* Slot 109 */
   966         -int
   967         -TclUpdateReturnInfo(iPtr)
   968         -    Interp * iPtr;
   969         -{
   970         -    return (tclIntStubsPtr->tclUpdateReturnInfo)(iPtr);
   971         -}
   972         -
   973         -/* Slot 110 is reserved */
   974         -/* Slot 111 */
   975         -void
   976         -Tcl_AddInterpResolvers(interp, name, cmdProc, varProc, compiledVarProc)
   977         -    Tcl_Interp * interp;
   978         -    char * name;
   979         -    Tcl_ResolveCmdProc * cmdProc;
   980         -    Tcl_ResolveVarProc * varProc;
   981         -    Tcl_ResolveCompiledVarProc * compiledVarProc;
   982         -{
   983         -    (tclIntStubsPtr->tcl_AddInterpResolvers)(interp, name, cmdProc, varProc, compiledVarProc);
   984         -}
   985         -
   986         -/* Slot 112 */
   987         -int
   988         -Tcl_AppendExportList(interp, nsPtr, objPtr)
   989         -    Tcl_Interp * interp;
   990         -    Tcl_Namespace * nsPtr;
   991         -    Tcl_Obj * objPtr;
   992         -{
   993         -    return (tclIntStubsPtr->tcl_AppendExportList)(interp, nsPtr, objPtr);
   994         -}
   995         -
   996         -/* Slot 113 */
   997         -Tcl_Namespace *
   998         -Tcl_CreateNamespace(interp, name, clientData, deleteProc)
   999         -    Tcl_Interp * interp;
  1000         -    char * name;
  1001         -    ClientData clientData;
  1002         -    Tcl_NamespaceDeleteProc * deleteProc;
  1003         -{
  1004         -    return (tclIntStubsPtr->tcl_CreateNamespace)(interp, name, clientData, deleteProc);
  1005         -}
  1006         -
  1007         -/* Slot 114 */
  1008         -void
  1009         -Tcl_DeleteNamespace(nsPtr)
  1010         -    Tcl_Namespace * nsPtr;
  1011         -{
  1012         -    (tclIntStubsPtr->tcl_DeleteNamespace)(nsPtr);
  1013         -}
  1014         -
  1015         -/* Slot 115 */
  1016         -int
  1017         -Tcl_Export(interp, nsPtr, pattern, resetListFirst)
  1018         -    Tcl_Interp * interp;
  1019         -    Tcl_Namespace * nsPtr;
  1020         -    char * pattern;
  1021         -    int resetListFirst;
  1022         -{
  1023         -    return (tclIntStubsPtr->tcl_Export)(interp, nsPtr, pattern, resetListFirst);
  1024         -}
  1025         -
  1026         -/* Slot 116 */
  1027         -Tcl_Command
  1028         -Tcl_FindCommand(interp, name, contextNsPtr, flags)
  1029         -    Tcl_Interp * interp;
  1030         -    char * name;
  1031         -    Tcl_Namespace * contextNsPtr;
  1032         -    int flags;
  1033         -{
  1034         -    return (tclIntStubsPtr->tcl_FindCommand)(interp, name, contextNsPtr, flags);
  1035         -}
  1036         -
  1037         -/* Slot 117 */
  1038         -Tcl_Namespace *
  1039         -Tcl_FindNamespace(interp, name, contextNsPtr, flags)
  1040         -    Tcl_Interp * interp;
  1041         -    char * name;
  1042         -    Tcl_Namespace * contextNsPtr;
  1043         -    int flags;
  1044         -{
  1045         -    return (tclIntStubsPtr->tcl_FindNamespace)(interp, name, contextNsPtr, flags);
  1046         -}
  1047         -
  1048         -/* Slot 118 */
  1049         -int
  1050         -Tcl_GetInterpResolvers(interp, name, resInfo)
  1051         -    Tcl_Interp * interp;
  1052         -    char * name;
  1053         -    Tcl_ResolverInfo * resInfo;
  1054         -{
  1055         -    return (tclIntStubsPtr->tcl_GetInterpResolvers)(interp, name, resInfo);
  1056         -}
  1057         -
  1058         -/* Slot 119 */
  1059         -int
  1060         -Tcl_GetNamespaceResolvers(namespacePtr, resInfo)
  1061         -    Tcl_Namespace * namespacePtr;
  1062         -    Tcl_ResolverInfo * resInfo;
  1063         -{
  1064         -    return (tclIntStubsPtr->tcl_GetNamespaceResolvers)(namespacePtr, resInfo);
  1065         -}
  1066         -
  1067         -/* Slot 120 */
  1068         -Tcl_Var
  1069         -Tcl_FindNamespaceVar(interp, name, contextNsPtr, flags)
  1070         -    Tcl_Interp * interp;
  1071         -    char * name;
  1072         -    Tcl_Namespace * contextNsPtr;
  1073         -    int flags;
  1074         -{
  1075         -    return (tclIntStubsPtr->tcl_FindNamespaceVar)(interp, name, contextNsPtr, flags);
  1076         -}
  1077         -
  1078         -/* Slot 121 */
  1079         -int
  1080         -Tcl_ForgetImport(interp, nsPtr, pattern)
  1081         -    Tcl_Interp * interp;
  1082         -    Tcl_Namespace * nsPtr;
  1083         -    char * pattern;
  1084         -{
  1085         -    return (tclIntStubsPtr->tcl_ForgetImport)(interp, nsPtr, pattern);
  1086         -}
  1087         -
  1088         -/* Slot 122 */
  1089         -Tcl_Command
  1090         -Tcl_GetCommandFromObj(interp, objPtr)
  1091         -    Tcl_Interp * interp;
  1092         -    Tcl_Obj * objPtr;
  1093         -{
  1094         -    return (tclIntStubsPtr->tcl_GetCommandFromObj)(interp, objPtr);
  1095         -}
  1096         -
  1097         -/* Slot 123 */
  1098         -void
  1099         -Tcl_GetCommandFullName(interp, command, objPtr)
  1100         -    Tcl_Interp * interp;
  1101         -    Tcl_Command command;
  1102         -    Tcl_Obj * objPtr;
  1103         -{
  1104         -    (tclIntStubsPtr->tcl_GetCommandFullName)(interp, command, objPtr);
  1105         -}
  1106         -
  1107         -/* Slot 124 */
  1108         -Tcl_Namespace *
  1109         -Tcl_GetCurrentNamespace(interp)
  1110         -    Tcl_Interp * interp;
  1111         -{
  1112         -    return (tclIntStubsPtr->tcl_GetCurrentNamespace)(interp);
  1113         -}
  1114         -
  1115         -/* Slot 125 */
  1116         -Tcl_Namespace *
  1117         -Tcl_GetGlobalNamespace(interp)
  1118         -    Tcl_Interp * interp;
  1119         -{
  1120         -    return (tclIntStubsPtr->tcl_GetGlobalNamespace)(interp);
  1121         -}
  1122         -
  1123         -/* Slot 126 */
  1124         -void
  1125         -Tcl_GetVariableFullName(interp, variable, objPtr)
  1126         -    Tcl_Interp * interp;
  1127         -    Tcl_Var variable;
  1128         -    Tcl_Obj * objPtr;
  1129         -{
  1130         -    (tclIntStubsPtr->tcl_GetVariableFullName)(interp, variable, objPtr);
  1131         -}
  1132         -
  1133         -/* Slot 127 */
  1134         -int
  1135         -Tcl_Import(interp, nsPtr, pattern, allowOverwrite)
  1136         -    Tcl_Interp * interp;
  1137         -    Tcl_Namespace * nsPtr;
  1138         -    char * pattern;
  1139         -    int allowOverwrite;
  1140         -{
  1141         -    return (tclIntStubsPtr->tcl_Import)(interp, nsPtr, pattern, allowOverwrite);
  1142         -}
  1143         -
  1144         -/* Slot 128 */
  1145         -void
  1146         -Tcl_PopCallFrame(interp)
  1147         -    Tcl_Interp* interp;
  1148         -{
  1149         -    (tclIntStubsPtr->tcl_PopCallFrame)(interp);
  1150         -}
  1151         -
  1152         -/* Slot 129 */
  1153         -int
  1154         -Tcl_PushCallFrame(interp, framePtr, nsPtr, isProcCallFrame)
  1155         -    Tcl_Interp* interp;
  1156         -    Tcl_CallFrame * framePtr;
  1157         -    Tcl_Namespace * nsPtr;
  1158         -    int isProcCallFrame;
  1159         -{
  1160         -    return (tclIntStubsPtr->tcl_PushCallFrame)(interp, framePtr, nsPtr, isProcCallFrame);
  1161         -}
  1162         -
  1163         -/* Slot 130 */
  1164         -int
  1165         -Tcl_RemoveInterpResolvers(interp, name)
  1166         -    Tcl_Interp * interp;
  1167         -    char * name;
  1168         -{
  1169         -    return (tclIntStubsPtr->tcl_RemoveInterpResolvers)(interp, name);
  1170         -}
  1171         -
  1172         -/* Slot 131 */
  1173         -void
  1174         -Tcl_SetNamespaceResolvers(namespacePtr, cmdProc, varProc, compiledVarProc)
  1175         -    Tcl_Namespace * namespacePtr;
  1176         -    Tcl_ResolveCmdProc * cmdProc;
  1177         -    Tcl_ResolveVarProc * varProc;
  1178         -    Tcl_ResolveCompiledVarProc * compiledVarProc;
  1179         -{
  1180         -    (tclIntStubsPtr->tcl_SetNamespaceResolvers)(namespacePtr, cmdProc, varProc, compiledVarProc);
  1181         -}
  1182         -
  1183         -/* Slot 132 */
  1184         -int
  1185         -TclpHasSockets(interp)
  1186         -    Tcl_Interp * interp;
  1187         -{
  1188         -    return (tclIntStubsPtr->tclpHasSockets)(interp);
  1189         -}
  1190         -
  1191         -/* Slot 133 */
  1192         -struct tm *
  1193         -TclpGetDate(time, useGMT)
  1194         -    TclpTime_t time;
  1195         -    int useGMT;
  1196         -{
  1197         -    return (tclIntStubsPtr->tclpGetDate)(time, useGMT);
  1198         -}
  1199         -
  1200         -/* Slot 134 */
  1201         -size_t
  1202         -TclpStrftime(s, maxsize, format, t)
  1203         -    char * s;
  1204         -    size_t maxsize;
  1205         -    CONST char * format;
  1206         -    CONST struct tm * t;
  1207         -{
  1208         -    return (tclIntStubsPtr->tclpStrftime)(s, maxsize, format, t);
  1209         -}
  1210         -
  1211         -/* Slot 135 */
  1212         -int
  1213         -TclpCheckStackSpace()
  1214         -{
  1215         -    return (tclIntStubsPtr->tclpCheckStackSpace)();
  1216         -}
  1217         -
  1218         -/* Slot 136 is reserved */
  1219         -/* Slot 137 */
  1220         -int
  1221         -TclpChdir(dirName)
  1222         -    CONST char * dirName;
  1223         -{
  1224         -    return (tclIntStubsPtr->tclpChdir)(dirName);
  1225         -}
  1226         -
  1227         -/* Slot 138 */
  1228         -char *
  1229         -TclGetEnv(name, valuePtr)
  1230         -    CONST char * name;
  1231         -    Tcl_DString * valuePtr;
  1232         -{
  1233         -    return (tclIntStubsPtr->tclGetEnv)(name, valuePtr);
  1234         -}
  1235         -
  1236         -/* Slot 139 */
  1237         -int
  1238         -TclpLoadFile(interp, fileName, sym1, sym2, proc1Ptr, proc2Ptr, clientDataPtr)
  1239         -    Tcl_Interp * interp;
  1240         -    char * fileName;
  1241         -    char * sym1;
  1242         -    char * sym2;
  1243         -    Tcl_PackageInitProc ** proc1Ptr;
  1244         -    Tcl_PackageInitProc ** proc2Ptr;
  1245         -    ClientData * clientDataPtr;
  1246         -{
  1247         -    return (tclIntStubsPtr->tclpLoadFile)(interp, fileName, sym1, sym2, proc1Ptr, proc2Ptr, clientDataPtr);
  1248         -}
  1249         -
  1250         -/* Slot 140 */
  1251         -int
  1252         -TclLooksLikeInt(bytes, length)
  1253         -    char * bytes;
  1254         -    int length;
  1255         -{
  1256         -    return (tclIntStubsPtr->tclLooksLikeInt)(bytes, length);
  1257         -}
  1258         -
  1259         -
  1260         -/* !END!: Do not edit above this line. */
  1261         -

Changes to generic/tclPlatDecls.h.

     2      2    * tclPlatDecls.h --
     3      3    *
     4      4    *	Declarations of platform specific Tcl APIs.
     5      5    *
     6      6    * Copyright (c) 1998-1999 by Scriptics Corporation.
     7      7    * All rights reserved.
     8      8    *
     9         - * RCS: @(#) $Id: tclPlatDecls.h,v 1.3.2.3 1999/03/14 18:56:10 stanton Exp $
            9  + * RCS: @(#) $Id: tclPlatDecls.h,v 1.3.2.4 1999/03/30 01:55:54 redman Exp $
    10     10    */
    11     11   
    12     12   #ifndef _TCLPLATDECLS
    13     13   #define _TCLPLATDECLS
    14     14   
    15     15   /* !BEGIN!: Do not edit below this line. */
    16     16   
................................................................................
    74     74   
    75     75   /*
    76     76    * Inline function declarations:
    77     77    */
    78     78   
    79     79   #ifdef MAC_TCL
    80     80   #ifndef Tcl_MacSetEventProc
    81         -#define Tcl_MacSetEventProc(procPtr) \
    82         -	(tclPlatStubsPtr->tcl_MacSetEventProc)(procPtr) /* 0 */
           81  +#define Tcl_MacSetEventProc \
           82  +	(tclPlatStubsPtr->tcl_MacSetEventProc) /* 0 */
    83     83   #endif
    84     84   #ifndef Tcl_MacConvertTextResource
    85         -#define Tcl_MacConvertTextResource(resource) \
    86         -	(tclPlatStubsPtr->tcl_MacConvertTextResource)(resource) /* 1 */
           85  +#define Tcl_MacConvertTextResource \
           86  +	(tclPlatStubsPtr->tcl_MacConvertTextResource) /* 1 */
    87     87   #endif
    88     88   #ifndef Tcl_MacEvalResource
    89         -#define Tcl_MacEvalResource(interp, resourceName, resourceNumber, fileName) \
    90         -	(tclPlatStubsPtr->tcl_MacEvalResource)(interp, resourceName, resourceNumber, fileName) /* 2 */
           89  +#define Tcl_MacEvalResource \
           90  +	(tclPlatStubsPtr->tcl_MacEvalResource) /* 2 */
    91     91   #endif
    92     92   #ifndef Tcl_MacFindResource
    93         -#define Tcl_MacFindResource(interp, resourceType, resourceName, resourceNumber, resFileRef, releaseIt) \
    94         -	(tclPlatStubsPtr->tcl_MacFindResource)(interp, resourceType, resourceName, resourceNumber, resFileRef, releaseIt) /* 3 */
           93  +#define Tcl_MacFindResource \
           94  +	(tclPlatStubsPtr->tcl_MacFindResource) /* 3 */
    95     95   #endif
    96     96   #ifndef Tcl_GetOSTypeFromObj
    97         -#define Tcl_GetOSTypeFromObj(interp, objPtr, osTypePtr) \
    98         -	(tclPlatStubsPtr->tcl_GetOSTypeFromObj)(interp, objPtr, osTypePtr) /* 4 */
           97  +#define Tcl_GetOSTypeFromObj \
           98  +	(tclPlatStubsPtr->tcl_GetOSTypeFromObj) /* 4 */
    99     99   #endif
   100    100   #ifndef Tcl_SetOSTypeObj
   101         -#define Tcl_SetOSTypeObj(objPtr, osType) \
   102         -	(tclPlatStubsPtr->tcl_SetOSTypeObj)(objPtr, osType) /* 5 */
          101  +#define Tcl_SetOSTypeObj \
          102  +	(tclPlatStubsPtr->tcl_SetOSTypeObj) /* 5 */
   103    103   #endif
   104    104   #ifndef Tcl_NewOSTypeObj
   105         -#define Tcl_NewOSTypeObj(osType) \
   106         -	(tclPlatStubsPtr->tcl_NewOSTypeObj)(osType) /* 6 */
          105  +#define Tcl_NewOSTypeObj \
          106  +	(tclPlatStubsPtr->tcl_NewOSTypeObj) /* 6 */
   107    107   #endif
   108    108   #ifndef strncasecmp
   109         -#define strncasecmp(s1, s2, n) \
   110         -	(tclPlatStubsPtr->strncasecmp)(s1, s2, n) /* 7 */
          109  +#define strncasecmp \
          110  +	(tclPlatStubsPtr->strncasecmp) /* 7 */
   111    111   #endif
   112    112   #ifndef strcasecmp
   113         -#define strcasecmp(s1, s2) \
   114         -	(tclPlatStubsPtr->strcasecmp)(s1, s2) /* 8 */
          113  +#define strcasecmp \
          114  +	(tclPlatStubsPtr->strcasecmp) /* 8 */
   115    115   #endif
   116    116   #endif /* MAC_TCL */
   117    117   
   118    118   #endif /* defined(USE_TCL_STUBS) && !defined(USE_TCL_STUB_PROCS) */
   119    119   
   120    120   /* !END!: Do not edit above this line. */
   121    121   
   122    122   #endif /* _TCLPLATDECLS */
   123    123   
   124    124   

Deleted generic/tclPlatStubs.c.

     1         -/* 
     2         - * tclPlatStubs.c --
     3         - *
     4         - *	This file contains the wrapper functions for the platform independent
     5         - *	unsupported Tcl API.
     6         - *
     7         - * Copyright (c) 1998-1999 by Scriptics Corporation.
     8         - * All rights reserved.
     9         - *
    10         - * RCS: @(#) $Id: tclPlatStubs.c,v 1.3.2.3 1999/03/14 18:56:10 stanton Exp $
    11         - */
    12         -
    13         -#include "tcl.h"
    14         -
    15         -/*
    16         - * WARNING: This file is automatically generated by the tools/genStubs.tcl
    17         - * script.  Any modifications to the function declarations below should be made
    18         - * in the generic/tclInt.decls script.
    19         - */
    20         -
    21         -/* !BEGIN!: Do not edit below this line. */
    22         -
    23         -/*
    24         - * Exported stub functions:
    25         - */
    26         -
    27         -#ifdef MAC_TCL
    28         -/* Slot 0 */
    29         -void
    30         -Tcl_MacSetEventProc(procPtr)
    31         -    Tcl_MacConvertEventPtr procPtr;
    32         -{
    33         -    (tclPlatStubsPtr->tcl_MacSetEventProc)(procPtr);
    34         -}
    35         -
    36         -/* Slot 1 */
    37         -char *
    38         -Tcl_MacConvertTextResource(resource)
    39         -    Handle resource;
    40         -{
    41         -    return (tclPlatStubsPtr->tcl_MacConvertTextResource)(resource);
    42         -}
    43         -
    44         -/* Slot 2 */
    45         -int
    46         -Tcl_MacEvalResource(interp, resourceName, resourceNumber, fileName)
    47         -    Tcl_Interp * interp;
    48         -    char * resourceName;
    49         -    int resourceNumber;
    50         -    char * fileName;
    51         -{
    52         -    return (tclPlatStubsPtr->tcl_MacEvalResource)(interp, resourceName, resourceNumber, fileName);
    53         -}
    54         -
    55         -/* Slot 3 */
    56         -Handle
    57         -Tcl_MacFindResource(interp, resourceType, resourceName, resourceNumber, resFileRef, releaseIt)
    58         -    Tcl_Interp * interp;
    59         -    long resourceType;
    60         -    char * resourceName;
    61         -    int resourceNumber;
    62         -    char * resFileRef;
    63         -    int * releaseIt;
    64         -{
    65         -    return (tclPlatStubsPtr->tcl_MacFindResource)(interp, resourceType, resourceName, resourceNumber, resFileRef, releaseIt);
    66         -}
    67         -
    68         -/* Slot 4 */
    69         -int
    70         -Tcl_GetOSTypeFromObj(interp, objPtr, osTypePtr)
    71         -    Tcl_Interp * interp;
    72         -    Tcl_Obj * objPtr;
    73         -    OSType * osTypePtr;
    74         -{
    75         -    return (tclPlatStubsPtr->tcl_GetOSTypeFromObj)(interp, objPtr, osTypePtr);
    76         -}
    77         -
    78         -/* Slot 5 */
    79         -void
    80         -Tcl_SetOSTypeObj(objPtr, osType)
    81         -    Tcl_Obj * objPtr;
    82         -    OSType osType;
    83         -{
    84         -    (tclPlatStubsPtr->tcl_SetOSTypeObj)(objPtr, osType);
    85         -}
    86         -
    87         -/* Slot 6 */
    88         -Tcl_Obj *
    89         -Tcl_NewOSTypeObj(osType)
    90         -    OSType osType;
    91         -{
    92         -    return (tclPlatStubsPtr->tcl_NewOSTypeObj)(osType);
    93         -}
    94         -
    95         -/* Slot 7 */
    96         -int
    97         -strncasecmp(s1, s2, n)
    98         -    CONST char * s1;
    99         -    CONST char * s2;
   100         -    size_t n;
   101         -{
   102         -    return (tclPlatStubsPtr->strncasecmp)(s1, s2, n);
   103         -}
   104         -
   105         -/* Slot 8 */
   106         -int
   107         -strcasecmp(s1, s2)
   108         -    CONST char * s1;
   109         -    CONST char * s2;
   110         -{
   111         -    return (tclPlatStubsPtr->strcasecmp)(s1, s2);
   112         -}
   113         -
   114         -#endif /* MAC_TCL */
   115         -
   116         -/* !END!: Do not edit above this line. */

Deleted generic/tclStubs.c.

     1         -/* 
     2         - * tclStubs.c --
     3         - *
     4         - *	This file contains the wrapper functions for the platform independent
     5         - *	public Tcl API.
     6         - *
     7         - * Copyright (c) 1998-1999 by Scriptics Corporation.
     8         - *
     9         - * See the file "license.terms" for information on usage and redistribution
    10         - * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
    11         - *
    12         - * RCS: @(#) $Id: tclStubs.c,v 1.3.2.8 1999/03/24 04:25:15 stanton Exp $
    13         - */
    14         -
    15         -#include "tcl.h"
    16         -
    17         -/*
    18         - * Undefine function macros that will interfere with the defintions below.
    19         - */
    20         -
    21         -#undef Tcl_Alloc
    22         -#undef Tcl_Free
    23         -#undef Tcl_Realloc
    24         -#undef Tcl_NewBooleanObj
    25         -#undef Tcl_NewByteArrayObj
    26         -#undef Tcl_NewDoubleObj
    27         -#undef Tcl_NewIntObj
    28         -#undef Tcl_NewListObj
    29         -#undef Tcl_NewLongObj
    30         -#undef Tcl_NewObj
    31         -#undef Tcl_NewStringObj
    32         -#undef Tcl_InitMemory
    33         -#undef Tcl_DumpActiveMemory
    34         -#undef Tcl_ValidateAllMemory
    35         -#undef Tcl_EvalObj
    36         -#undef Tcl_GlobalEvalObj
    37         -#undef Tcl_MutexLock
    38         -#undef Tcl_MutexUnlock
    39         -#undef Tcl_ConditionNotify
    40         -#undef Tcl_ConditionWait
    41         -
    42         -/*
    43         - * WARNING: This file is automatically generated by the tools/genStubs.tcl
    44         - * script.  Any modifications to the function declarations below should be made
    45         - * in the generic/tcl.decls script.
    46         - */
    47         -
    48         -/* !BEGIN!: Do not edit below this line. */
    49         -
    50         -/*
    51         - * Exported stub functions:
    52         - */
    53         -
    54         -/* Slot 0 */
    55         -int
    56         -Tcl_PkgProvideEx(interp, name, version, clientData)
    57         -    Tcl_Interp * interp;
    58         -    char * name;
    59         -    char * version;
    60         -    ClientData clientData;
    61         -{
    62         -    return (tclStubsPtr->tcl_PkgProvideEx)(interp, name, version, clientData);
    63         -}
    64         -
    65         -/* Slot 1 */
    66         -char *
    67         -Tcl_PkgRequireEx(interp, name, version, exact, clientDataPtr)
    68         -    Tcl_Interp * interp;
    69         -    char * name;
    70         -    char * version;
    71         -    int exact;
    72         -    ClientData * clientDataPtr;
    73         -{
    74         -    return (tclStubsPtr->tcl_PkgRequireEx)(interp, name, version, exact, clientDataPtr);
    75         -}
    76         -
    77         -/* Slot 2 */
    78         -void
    79         -Tcl_Panic TCL_VARARGS_DEF(char *,format)
    80         -{
    81         -    char * var;
    82         -    va_list argList;
    83         -
    84         -    var = (char *) TCL_VARARGS_START(char *,format,argList);
    85         -
    86         -    (tclStubsPtr->tcl_PanicVA)(var, argList);
    87         -    va_end(argList);
    88         -}
    89         -
    90         -/* Slot 3 */
    91         -char *
    92         -Tcl_Alloc(size)
    93         -    unsigned int size;
    94         -{
    95         -    return (tclStubsPtr->tcl_Alloc)(size);
    96         -}
    97         -
    98         -/* Slot 4 */
    99         -void
   100         -Tcl_Free(ptr)
   101         -    char * ptr;
   102         -{
   103         -    (tclStubsPtr->tcl_Free)(ptr);
   104         -}
   105         -
   106         -/* Slot 5 */
   107         -char *
   108         -Tcl_Realloc(ptr, size)
   109         -    char * ptr;
   110         -    unsigned int size;
   111         -{
   112         -    return (tclStubsPtr->tcl_Realloc)(ptr, size);
   113         -}
   114         -
   115         -/* Slot 6 */
   116         -char *
   117         -Tcl_DbCkalloc(size, file, line)
   118         -    unsigned int size;
   119         -    char * file;
   120         -    int line;
   121         -{
   122         -    return (tclStubsPtr->tcl_DbCkalloc)(size, file, line);
   123         -}
   124         -
   125         -/* Slot 7 */
   126         -int
   127         -Tcl_DbCkfree(ptr, file, line)
   128         -    char * ptr;
   129         -    char * file;
   130         -    int line;
   131         -{
   132         -    return (tclStubsPtr->tcl_DbCkfree)(ptr, file, line);
   133         -}
   134         -
   135         -/* Slot 8 */
   136         -char *
   137         -Tcl_DbCkrealloc(ptr, size, file, line)
   138         -    char * ptr;
   139         -    unsigned int size;
   140         -    char * file;
   141         -    int line;
   142         -{
   143         -    return (tclStubsPtr->tcl_DbCkrealloc)(ptr, size, file, line);
   144         -}
   145         -
   146         -#if !defined(__WIN32__) && !defined(MAC_TCL) /* UNIX */
   147         -/* Slot 9 */
   148         -void
   149         -Tcl_CreateFileHandler(fd, mask, proc, clientData)
   150         -    int fd;
   151         -    int mask;
   152         -    Tcl_FileProc * proc;
   153         -    ClientData clientData;
   154         -{
   155         -    (tclStubsPtr->tcl_CreateFileHandler)(fd, mask, proc, clientData);
   156         -}
   157         -
   158         -#endif /* UNIX */
   159         -#if !defined(__WIN32__) && !defined(MAC_TCL) /* UNIX */
   160         -/* Slot 10 */
   161         -void
   162         -Tcl_DeleteFileHandler(fd)
   163         -    int fd;
   164         -{
   165         -    (tclStubsPtr->tcl_DeleteFileHandler)(fd);
   166         -}
   167         -
   168         -#endif /* UNIX */
   169         -/* Slot 11 */
   170         -void
   171         -Tcl_SetTimer(timePtr)
   172         -    Tcl_Time * timePtr;
   173         -{
   174         -    (tclStubsPtr->tcl_SetTimer)(timePtr);
   175         -}
   176         -
   177         -/* Slot 12 */
   178         -void
   179         -Tcl_Sleep(ms)
   180         -    int ms;
   181         -{
   182         -    (tclStubsPtr->tcl_Sleep)(ms);
   183         -}
   184         -
   185         -/* Slot 13 */
   186         -int
   187         -Tcl_WaitForEvent(timePtr)
   188         -    Tcl_Time * timePtr;
   189         -{
   190         -    return (tclStubsPtr->tcl_WaitForEvent)(timePtr);
   191         -}
   192         -
   193         -/* Slot 14 */
   194         -int
   195         -Tcl_AppendAllObjTypes(interp, objPtr)
   196         -    Tcl_Interp * interp;
   197         -    Tcl_Obj * objPtr;
   198         -{
   199         -    return (tclStubsPtr->tcl_AppendAllObjTypes)(interp, objPtr);
   200         -}
   201         -
   202         -/* Slot 15 */
   203         -void
   204         -Tcl_AppendStringsToObj TCL_VARARGS_DEF(Tcl_Obj *,objPtr)
   205         -{
   206         -    Tcl_Obj * var;
   207         -    va_list argList;
   208         -
   209         -    var = (Tcl_Obj *) TCL_VARARGS_START(Tcl_Obj *,objPtr,argList);
   210         -
   211         -    (tclStubsPtr->tcl_AppendStringsToObjVA)(var, argList);
   212         -    va_end(argList);
   213         -}
   214         -
   215         -/* Slot 16 */
   216         -void
   217         -Tcl_AppendToObj(objPtr, bytes, length)
   218         -    Tcl_Obj * objPtr;
   219         -    char * bytes;
   220         -    int length;
   221         -{
   222         -    (tclStubsPtr->tcl_AppendToObj)(objPtr, bytes, length);
   223         -}
   224         -
   225         -/* Slot 17 */
   226         -Tcl_Obj *
   227         -Tcl_ConcatObj(objc, objv)
   228         -    int objc;
   229         -    Tcl_Obj *CONST objv[];
   230         -{
   231         -    return (tclStubsPtr->tcl_ConcatObj)(objc, objv);
   232         -}
   233         -
   234         -/* Slot 18 */
   235         -int
   236         -Tcl_ConvertToType(interp, objPtr, typePtr)
   237         -    Tcl_Interp * interp;
   238         -    Tcl_Obj * objPtr;
   239         -    Tcl_ObjType * typePtr;
   240         -{
   241         -    return (tclStubsPtr->tcl_ConvertToType)(interp, objPtr, typePtr);
   242         -}
   243         -
   244         -/* Slot 19 */
   245         -void
   246         -Tcl_DbDecrRefCount(objPtr, file, line)
   247         -    Tcl_Obj * objPtr;
   248         -    char * file;
   249         -    int line;
   250         -{
   251         -    (tclStubsPtr->tcl_DbDecrRefCount)(objPtr, file, line);
   252         -}
   253         -
   254         -/* Slot 20 */
   255         -void
   256         -Tcl_DbIncrRefCount(objPtr, file, line)
   257         -    Tcl_Obj * objPtr;
   258         -    char * file;
   259         -    int line;
   260         -{
   261         -    (tclStubsPtr->tcl_DbIncrRefCount)(objPtr, file, line);
   262         -}
   263         -
   264         -/* Slot 21 */
   265         -int
   266         -Tcl_DbIsShared(objPtr, file, line)
   267         -    Tcl_Obj * objPtr;
   268         -    char * file;
   269         -    int line;
   270         -{
   271         -    return (tclStubsPtr->tcl_DbIsShared)(objPtr, file, line);
   272         -}
   273         -
   274         -/* Slot 22 */
   275         -Tcl_Obj *
   276         -Tcl_DbNewBooleanObj(boolValue, file, line)
   277         -    int boolValue;
   278         -    char * file;
   279         -    int line;
   280         -{
   281         -    return (tclStubsPtr->tcl_DbNewBooleanObj)(boolValue, file, line);
   282         -}
   283         -
   284         -/* Slot 23 */
   285         -Tcl_Obj *
   286         -Tcl_DbNewByteArrayObj(bytes, length, file, line)
   287         -    unsigned char * bytes;
   288         -    int length;
   289         -    char * file;
   290         -    int line;
   291         -{
   292         -    return (tclStubsPtr->tcl_DbNewByteArrayObj)(bytes, length, file, line);
   293         -}
   294         -
   295         -/* Slot 24 */
   296         -Tcl_Obj *
   297         -Tcl_DbNewDoubleObj(doubleValue, file, line)
   298         -    double doubleValue;
   299         -    char * file;
   300         -    int line;
   301         -{
   302         -    return (tclStubsPtr->tcl_DbNewDoubleObj)(doubleValue, file, line);
   303         -}
   304         -
   305         -/* Slot 25 */
   306         -Tcl_Obj *
   307         -Tcl_DbNewListObj(objc, objv, file, line)
   308         -    int objc;
   309         -    Tcl_Obj *CONST objv[];
   310         -    char * file;
   311         -    int line;
   312         -{
   313         -    return (tclStubsPtr->tcl_DbNewListObj)(objc, objv, file, line);
   314         -}
   315         -
   316         -/* Slot 26 */
   317         -Tcl_Obj *
   318         -Tcl_DbNewLongObj(longValue, file, line)
   319         -    long longValue;
   320         -    char * file;
   321         -    int line;
   322         -{
   323         -    return (tclStubsPtr->tcl_DbNewLongObj)(longValue, file, line);
   324         -}
   325         -
   326         -/* Slot 27 */
   327         -Tcl_Obj *
   328         -Tcl_DbNewObj(file, line)
   329         -    char * file;
   330         -    int line;
   331         -{
   332         -    return (tclStubsPtr->tcl_DbNewObj)(file, line);
   333         -}
   334         -
   335         -/* Slot 28 */
   336         -Tcl_Obj *
   337         -Tcl_DbNewStringObj(bytes, length, file, line)
   338         -    CONST char * bytes;
   339         -    int length;
   340         -    char * file;
   341         -    int line;
   342         -{
   343         -    return (tclStubsPtr->tcl_DbNewStringObj)(bytes, length, file, line);
   344         -}
   345         -
   346         -/* Slot 29 */
   347         -Tcl_Obj *
   348         -Tcl_DuplicateObj(objPtr)
   349         -    Tcl_Obj * objPtr;
   350         -{
   351         -    return (tclStubsPtr->tcl_DuplicateObj)(objPtr);
   352         -}
   353         -
   354         -/* Slot 30 */
   355         -void
   356         -TclFreeObj(objPtr)
   357         -    Tcl_Obj * objPtr;
   358         -{
   359         -    (tclStubsPtr->tclFreeObj)(objPtr);
   360         -}
   361         -
   362         -/* Slot 31 */
   363         -int
   364         -Tcl_GetBoolean(interp, str, boolPtr)
   365         -    Tcl_Interp * interp;
   366         -    char * str;
   367         -    int * boolPtr;
   368         -{
   369         -    return (tclStubsPtr->tcl_GetBoolean)(interp, str, boolPtr);
   370         -}
   371         -
   372         -/* Slot 32 */
   373         -int
   374         -Tcl_GetBooleanFromObj(interp, objPtr, boolPtr)
   375         -    Tcl_Interp * interp;
   376         -    Tcl_Obj * objPtr;
   377         -    int * boolPtr;
   378         -{
   379         -    return (tclStubsPtr->tcl_GetBooleanFromObj)(interp, objPtr, boolPtr);
   380         -}
   381         -
   382         -/* Slot 33 */
   383         -unsigned char *
   384         -Tcl_GetByteArrayFromObj(objPtr, lengthPtr)
   385         -    Tcl_Obj * objPtr;
   386         -    int * lengthPtr;
   387         -{
   388         -    return (tclStubsPtr->tcl_GetByteArrayFromObj)(objPtr, lengthPtr);
   389         -}
   390         -
   391         -/* Slot 34 */
   392         -int
   393         -Tcl_GetDouble(interp, str, doublePtr)
   394         -    Tcl_Interp * interp;
   395         -    char * str;
   396         -    double * doublePtr;
   397         -{
   398         -    return (tclStubsPtr->tcl_GetDouble)(interp, str, doublePtr);
   399         -}
   400         -
   401         -/* Slot 35 */
   402         -int
   403         -Tcl_GetDoubleFromObj(interp, objPtr, doublePtr)
   404         -    Tcl_Interp * interp;
   405         -    Tcl_Obj * objPtr;
   406         -    double * doublePtr;
   407         -{
   408         -    return (tclStubsPtr->tcl_GetDoubleFromObj)(interp, objPtr, doublePtr);
   409         -}
   410         -
   411         -/* Slot 36 */
   412         -int
   413         -Tcl_GetIndexFromObj(interp, objPtr, tablePtr, msg, flags, indexPtr)
   414         -    Tcl_Interp * interp;
   415         -    Tcl_Obj * objPtr;
   416         -    char ** tablePtr;
   417         -    char * msg;
   418         -    int flags;
   419         -    int * indexPtr;
   420         -{
   421         -    return (tclStubsPtr->tcl_GetIndexFromObj)(interp, objPtr, tablePtr, msg, flags, indexPtr);
   422         -}
   423         -
   424         -/* Slot 37 */
   425         -int
   426         -Tcl_GetInt(interp, str, intPtr)
   427         -    Tcl_Interp * interp;
   428         -    char * str;
   429         -    int * intPtr;
   430         -{
   431         -    return (tclStubsPtr->tcl_GetInt)(interp, str, intPtr);
   432         -}
   433         -
   434         -/* Slot 38 */
   435         -int
   436         -Tcl_GetIntFromObj(interp, objPtr, intPtr)
   437         -    Tcl_Interp * interp;
   438         -    Tcl_Obj * objPtr;
   439         -    int * intPtr;
   440         -{
   441         -    return (tclStubsPtr->tcl_GetIntFromObj)(interp, objPtr, intPtr);
   442         -}
   443         -
   444         -/* Slot 39 */
   445         -int
   446         -Tcl_GetLongFromObj(interp, objPtr, longPtr)
   447         -    Tcl_Interp * interp;
   448         -    Tcl_Obj * objPtr;
   449         -    long * longPtr;
   450         -{
   451         -    return (tclStubsPtr->tcl_GetLongFromObj)(interp, objPtr, longPtr);
   452         -}
   453         -
   454         -/* Slot 40 */
   455         -Tcl_ObjType *
   456         -Tcl_GetObjType(typeName)
   457         -    char * typeName;
   458         -{
   459         -    return (tclStubsPtr->tcl_GetObjType)(typeName);
   460         -}
   461         -
   462         -/* Slot 41 */
   463         -char *
   464         -Tcl_GetStringFromObj(objPtr, lengthPtr)
   465         -    Tcl_Obj * objPtr;
   466         -    int * lengthPtr;
   467         -{
   468         -    return (tclStubsPtr->tcl_GetStringFromObj)(objPtr, lengthPtr);
   469         -}
   470         -
   471         -/* Slot 42 */
   472         -void
   473         -Tcl_InvalidateStringRep(objPtr)
   474         -    Tcl_Obj * objPtr;
   475         -{
   476         -    (tclStubsPtr->tcl_InvalidateStringRep)(objPtr);
   477         -}
   478         -
   479         -/* Slot 43 */
   480         -int
   481         -Tcl_ListObjAppendList(interp, listPtr, elemListPtr)
   482         -    Tcl_Interp * interp;
   483         -    Tcl_Obj * listPtr;
   484         -    Tcl_Obj * elemListPtr;
   485         -{
   486         -    return (tclStubsPtr->tcl_ListObjAppendList)(interp, listPtr, elemListPtr);
   487         -}
   488         -
   489         -/* Slot 44 */
   490         -int
   491         -Tcl_ListObjAppendElement(interp, listPtr, objPtr)
   492         -    Tcl_Interp * interp;
   493         -    Tcl_Obj * listPtr;
   494         -    Tcl_Obj * objPtr;
   495         -{
   496         -    return (tclStubsPtr->tcl_ListObjAppendElement)(interp, listPtr, objPtr);
   497         -}
   498         -
   499         -/* Slot 45 */
   500         -int
   501         -Tcl_ListObjGetElements(interp, listPtr, objcPtr, objvPtr)
   502         -    Tcl_Interp * interp;
   503         -    Tcl_Obj * listPtr;
   504         -    int * objcPtr;
   505         -    Tcl_Obj *** objvPtr;
   506         -{
   507         -    return (tclStubsPtr->tcl_ListObjGetElements)(interp, listPtr, objcPtr, objvPtr);
   508         -}
   509         -
   510         -/* Slot 46 */
   511         -int
   512         -Tcl_ListObjIndex(interp, listPtr, index, objPtrPtr)
   513         -    Tcl_Interp * interp;
   514         -    Tcl_Obj * listPtr;
   515         -    int index;
   516         -    Tcl_Obj ** objPtrPtr;
   517         -{
   518         -    return (tclStubsPtr->tcl_ListObjIndex)(interp, listPtr, index, objPtrPtr);
   519         -}
   520         -
   521         -/* Slot 47 */
   522         -int
   523         -Tcl_ListObjLength(interp, listPtr, intPtr)
   524         -    Tcl_Interp * interp;
   525         -    Tcl_Obj * listPtr;
   526         -    int * intPtr;
   527         -{
   528         -    return (tclStubsPtr->tcl_ListObjLength)(interp, listPtr, intPtr);
   529         -}
   530         -
   531         -/* Slot 48 */
   532         -int
   533         -Tcl_ListObjReplace(interp, listPtr, first, count, objc, objv)
   534         -    Tcl_Interp * interp;
   535         -    Tcl_Obj * listPtr;
   536         -    int first;
   537         -    int count;
   538         -    int objc;
   539         -    Tcl_Obj *CONST objv[];
   540         -{
   541         -    return (tclStubsPtr->tcl_ListObjReplace)(interp, listPtr, first, count, objc, objv);
   542         -}
   543         -
   544         -/* Slot 49 */
   545         -Tcl_Obj *
   546         -Tcl_NewBooleanObj(boolValue)
   547         -    int boolValue;
   548         -{
   549         -    return (tclStubsPtr->tcl_NewBooleanObj)(boolValue);
   550         -}
   551         -
   552         -/* Slot 50 */
   553         -Tcl_Obj *
   554         -Tcl_NewByteArrayObj(bytes, length)
   555         -    unsigned char * bytes;
   556         -    int length;
   557         -{
   558         -    return (tclStubsPtr->tcl_NewByteArrayObj)(bytes, length);
   559         -}
   560         -
   561         -/* Slot 51 */
   562         -Tcl_Obj *
   563         -Tcl_NewDoubleObj(doubleValue)
   564         -    double doubleValue;
   565         -{
   566         -    return (tclStubsPtr->tcl_NewDoubleObj)(doubleValue);
   567         -}
   568         -
   569         -/* Slot 52 */
   570         -Tcl_Obj *
   571         -Tcl_NewIntObj(intValue)
   572         -    int intValue;
   573         -{
   574         -    return (tclStubsPtr->tcl_NewIntObj)(intValue);
   575         -}
   576         -
   577         -/* Slot 53 */
   578         -Tcl_Obj *
   579         -Tcl_NewListObj(objc, objv)
   580         -    int objc;
   581         -    Tcl_Obj *CONST objv[];
   582         -{
   583         -    return (tclStubsPtr->tcl_NewListObj)(objc, objv);
   584         -}
   585         -
   586         -/* Slot 54 */
   587         -Tcl_Obj *
   588         -Tcl_NewLongObj(longValue)
   589         -    long longValue;
   590         -{
   591         -    return (tclStubsPtr->tcl_NewLongObj)(longValue);
   592         -}
   593         -
   594         -/* Slot 55 */
   595         -Tcl_Obj *
   596         -Tcl_NewObj()
   597         -{
   598         -    return (tclStubsPtr->tcl_NewObj)();
   599         -}
   600         -
   601         -/* Slot 56 */
   602         -Tcl_Obj *
   603         -Tcl_NewStringObj(bytes, length)
   604         -    CONST char * bytes;
   605         -    int length;
   606         -{
   607         -    return (tclStubsPtr->tcl_NewStringObj)(bytes, length);
   608         -}
   609         -
   610         -/* Slot 57 */
   611         -void
   612         -Tcl_SetBooleanObj(objPtr, boolValue)
   613         -    Tcl_Obj * objPtr;
   614         -    int boolValue;
   615         -{
   616         -    (tclStubsPtr->tcl_SetBooleanObj)(objPtr, boolValue);
   617         -}
   618         -
   619         -/* Slot 58 */
   620         -unsigned char *
   621         -Tcl_SetByteArrayLength(objPtr, length)
   622         -    Tcl_Obj * objPtr;
   623         -    int length;
   624         -{
   625         -    return (tclStubsPtr->tcl_SetByteArrayLength)(objPtr, length);
   626         -}
   627         -
   628         -/* Slot 59 */
   629         -void
   630         -Tcl_SetByteArrayObj(objPtr, bytes, length)
   631         -    Tcl_Obj * objPtr;
   632         -    unsigned char * bytes;
   633         -    int length;
   634         -{
   635         -    (tclStubsPtr->tcl_SetByteArrayObj)(objPtr, bytes, length);
   636         -}
   637         -
   638         -/* Slot 60 */
   639         -void
   640         -Tcl_SetDoubleObj(objPtr, doubleValue)
   641         -    Tcl_Obj * objPtr;
   642         -    double doubleValue;
   643         -{
   644         -    (tclStubsPtr->tcl_SetDoubleObj)(objPtr, doubleValue);
   645         -}
   646         -
   647         -/* Slot 61 */
   648         -void
   649         -Tcl_SetIntObj(objPtr, intValue)
   650         -    Tcl_Obj * objPtr;
   651         -    int intValue;
   652         -{
   653         -    (tclStubsPtr->tcl_SetIntObj)(objPtr, intValue);
   654         -}
   655         -
   656         -/* Slot 62 */
   657         -void
   658         -Tcl_SetListObj(objPtr, objc, objv)
   659         -    Tcl_Obj * objPtr;
   660         -    int objc;
   661         -    Tcl_Obj *CONST objv[];
   662         -{
   663         -    (tclStubsPtr->tcl_SetListObj)(objPtr, objc, objv);
   664         -}
   665         -
   666         -/* Slot 63 */
   667         -void
   668         -Tcl_SetLongObj(objPtr, longValue)
   669         -    Tcl_Obj * objPtr;
   670         -    long longValue;
   671         -{
   672         -    (tclStubsPtr->tcl_SetLongObj)(objPtr, longValue);
   673         -}
   674         -
   675         -/* Slot 64 */
   676         -void
   677         -Tcl_SetObjLength(objPtr, length)
   678         -    Tcl_Obj * objPtr;
   679         -    int length;
   680         -{
   681         -    (tclStubsPtr->tcl_SetObjLength)(objPtr, length);
   682         -}
   683         -
   684         -/* Slot 65 */
   685         -void
   686         -Tcl_SetStringObj(objPtr, bytes, length)
   687         -    Tcl_Obj * objPtr;
   688         -    char * bytes;
   689         -    int length;
   690         -{
   691         -    (tclStubsPtr->tcl_SetStringObj)(objPtr, bytes, length);
   692         -}
   693         -
   694         -/* Slot 66 */
   695         -void
   696         -Tcl_AddErrorInfo(interp, message)
   697         -    Tcl_Interp * interp;
   698         -    CONST char * message;
   699         -{
   700         -    (tclStubsPtr->tcl_AddErrorInfo)(interp, message);
   701         -}
   702         -
   703         -/* Slot 67 */
   704         -void
   705         -Tcl_AddObjErrorInfo(interp, message, length)
   706         -    Tcl_Interp * interp;
   707         -    CONST char * message;
   708         -    int length;
   709         -{
   710         -    (tclStubsPtr->tcl_AddObjErrorInfo)(interp, message, length);
   711         -}
   712         -
   713         -/* Slot 68 */
   714         -void
   715         -Tcl_AllowExceptions(interp)
   716         -    Tcl_Interp * interp;
   717         -{
   718         -    (tclStubsPtr->tcl_AllowExceptions)(interp);
   719         -}
   720         -
   721         -/* Slot 69 */
   722         -void
   723         -Tcl_AppendElement(interp, string)
   724         -    Tcl_Interp * interp;
   725         -    CONST char * string;
   726         -{
   727         -    (tclStubsPtr->tcl_AppendElement)(interp, string);
   728         -}
   729         -
   730         -/* Slot 70 */
   731         -void
   732         -Tcl_AppendResult TCL_VARARGS_DEF(Tcl_Interp *,interp)
   733         -{
   734         -    Tcl_Interp * var;
   735         -    va_list argList;
   736         -
   737         -    var = (Tcl_Interp *) TCL_VARARGS_START(Tcl_Interp *,interp,argList);
   738         -
   739         -    (tclStubsPtr->tcl_AppendResultVA)(var, argList);
   740         -    va_end(argList);
   741         -}
   742         -
   743         -/* Slot 71 */
   744         -Tcl_AsyncHandler
   745         -Tcl_AsyncCreate(proc, clientData)
   746         -    Tcl_AsyncProc * proc;
   747         -    ClientData clientData;
   748         -{
   749         -    return (tclStubsPtr->tcl_AsyncCreate)(proc, clientData);
   750         -}
   751         -
   752         -/* Slot 72 */
   753         -void
   754         -Tcl_AsyncDelete(async)
   755         -    Tcl_AsyncHandler async;
   756         -{
   757         -    (tclStubsPtr->tcl_AsyncDelete)(async);
   758         -}
   759         -
   760         -/* Slot 73 */
   761         -int
   762         -Tcl_AsyncInvoke(interp, code)
   763         -    Tcl_Interp * interp;
   764         -    int code;
   765         -{
   766         -    return (tclStubsPtr->tcl_AsyncInvoke)(interp, code);
   767         -}
   768         -
   769         -/* Slot 74 */
   770         -void
   771         -Tcl_AsyncMark(async)
   772         -    Tcl_AsyncHandler async;
   773         -{
   774         -    (tclStubsPtr->tcl_AsyncMark)(async);
   775         -}
   776         -
   777         -/* Slot 75 */
   778         -int
   779         -Tcl_AsyncReady()
   780         -{
   781         -    return (tclStubsPtr->tcl_AsyncReady)();
   782         -}
   783         -
   784         -/* Slot 76 */
   785         -void
   786         -Tcl_BackgroundError(interp)
   787         -    Tcl_Interp * interp;
   788         -{
   789         -    (tclStubsPtr->tcl_BackgroundError)(interp);
   790         -}
   791         -
   792         -/* Slot 77 */
   793         -char
   794         -Tcl_Backslash(src, readPtr)
   795         -    CONST char * src;
   796         -    int * readPtr;
   797         -{
   798         -    return (tclStubsPtr->tcl_Backslash)(src, readPtr);
   799         -}
   800         -
   801         -/* Slot 78 */
   802         -int
   803         -Tcl_BadChannelOption(interp, optionName, optionList)
   804         -    Tcl_Interp * interp;
   805         -    char * optionName;
   806         -    char * optionList;
   807         -{
   808         -    return (tclStubsPtr->tcl_BadChannelOption)(interp, optionName, optionList);
   809         -}
   810         -
   811         -/* Slot 79 */
   812         -void
   813         -Tcl_CallWhenDeleted(interp, proc, clientData)
   814         -    Tcl_Interp * interp;
   815         -    Tcl_InterpDeleteProc * proc;
   816         -    ClientData clientData;
   817         -{
   818         -    (tclStubsPtr->tcl_CallWhenDeleted)(interp, proc, clientData);
   819         -}
   820         -
   821         -/* Slot 80 */
   822         -void
   823         -Tcl_CancelIdleCall(idleProc, clientData)
   824         -    Tcl_IdleProc * idleProc;
   825         -    ClientData clientData;
   826         -{
   827         -    (tclStubsPtr->tcl_CancelIdleCall)(idleProc, clientData);
   828         -}
   829         -
   830         -/* Slot 81 */
   831         -int
   832         -Tcl_Close(interp, chan)
   833         -    Tcl_Interp * interp;
   834         -    Tcl_Channel chan;
   835         -{
   836         -    return (tclStubsPtr->tcl_Close)(interp, chan);
   837         -}
   838         -
   839         -/* Slot 82 */
   840         -int
   841         -Tcl_CommandComplete(cmd)
   842         -    char * cmd;
   843         -{
   844         -    return (tclStubsPtr->tcl_CommandComplete)(cmd);
   845         -}
   846         -
   847         -/* Slot 83 */
   848         -char *
   849         -Tcl_Concat(argc, argv)
   850         -    int argc;
   851         -    char ** argv;
   852         -{
   853         -    return (tclStubsPtr->tcl_Concat)(argc, argv);
   854         -}
   855         -
   856         -/* Slot 84 */
   857         -int
   858         -Tcl_ConvertElement(src, dst, flags)
   859         -    CONST char * src;
   860         -    char * dst;
   861         -    int flags;
   862         -{
   863         -    return (tclStubsPtr->tcl_ConvertElement)(src, dst, flags);
   864         -}
   865         -
   866         -/* Slot 85 */
   867         -int
   868         -Tcl_ConvertCountedElement(src, length, dst, flags)
   869         -    CONST char * src;
   870         -    int length;
   871         -    char * dst;
   872         -    int flags;
   873         -{
   874         -    return (tclStubsPtr->tcl_ConvertCountedElement)(src, length, dst, flags);
   875         -}
   876         -
   877         -/* Slot 86 */
   878         -int
   879         -Tcl_CreateAlias(slave, slaveCmd, target, targetCmd, argc, argv)
   880         -    Tcl_Interp * slave;
   881         -    char * slaveCmd;
   882         -    Tcl_Interp * target;
   883         -    char * targetCmd;
   884         -    int argc;
   885         -    char ** argv;
   886         -{
   887         -    return (tclStubsPtr->tcl_CreateAlias)(slave, slaveCmd, target, targetCmd, argc, argv);
   888         -}
   889         -
   890         -/* Slot 87 */
   891         -int
   892         -Tcl_CreateAliasObj(slave, slaveCmd, target, targetCmd, objc, objv)
   893         -    Tcl_Interp * slave;
   894         -    char * slaveCmd;
   895         -    Tcl_Interp * target;
   896         -    char * targetCmd;
   897         -    int objc;
   898         -    Tcl_Obj *CONST objv[];
   899         -{
   900         -    return (tclStubsPtr->tcl_CreateAliasObj)(slave, slaveCmd, target, targetCmd, objc, objv);
   901         -}
   902         -
   903         -/* Slot 88 */
   904         -Tcl_Channel
   905         -Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
   906         -    Tcl_ChannelType * typePtr;
   907         -    char * chanName;
   908         -    ClientData instanceData;
   909         -    int mask;
   910         -{
   911         -    return (tclStubsPtr->tcl_CreateChannel)(typePtr, chanName, instanceData, mask);
   912         -}
   913         -
   914         -/* Slot 89 */
   915         -void
   916         -Tcl_CreateChannelHandler(chan, mask, proc, clientData)
   917         -    Tcl_Channel chan;
   918         -    int mask;
   919         -    Tcl_ChannelProc * proc;
   920         -    ClientData clientData;
   921         -{
   922         -    (tclStubsPtr->tcl_CreateChannelHandler)(chan, mask, proc, clientData);
   923         -}
   924         -
   925         -/* Slot 90 */
   926         -void
   927         -Tcl_CreateCloseHandler(chan, proc, clientData)
   928         -    Tcl_Channel chan;
   929         -    Tcl_CloseProc * proc;
   930         -    ClientData clientData;
   931         -{
   932         -    (tclStubsPtr->tcl_CreateCloseHandler)(chan, proc, clientData);
   933         -}
   934         -
   935         -/* Slot 91 */
   936         -Tcl_Command
   937         -Tcl_CreateCommand(interp, cmdName, proc, clientData, deleteProc)
   938         -    Tcl_Interp * interp;
   939         -    char * cmdName;
   940         -    Tcl_CmdProc * proc;
   941         -    ClientData clientData;
   942         -    Tcl_CmdDeleteProc * deleteProc;
   943         -{
   944         -    return (tclStubsPtr->tcl_CreateCommand)(interp, cmdName, proc, clientData, deleteProc);
   945         -}
   946         -
   947         -/* Slot 92 */
   948         -void
   949         -Tcl_CreateEventSource(setupProc, checkProc, clientData)
   950         -    Tcl_EventSetupProc * setupProc;
   951         -    Tcl_EventCheckProc * checkProc;
   952         -    ClientData clientData;
   953         -{
   954         -    (tclStubsPtr->tcl_CreateEventSource)(setupProc, checkProc, clientData);
   955         -}
   956         -
   957         -/* Slot 93 */
   958         -void
   959         -Tcl_CreateExitHandler(proc, clientData)
   960         -    Tcl_ExitProc * proc;
   961         -    ClientData clientData;
   962         -{
   963         -    (tclStubsPtr->tcl_CreateExitHandler)(proc, clientData);
   964         -}
   965         -
   966         -/* Slot 94 */
   967         -Tcl_Interp *
   968         -Tcl_CreateInterp()
   969         -{
   970         -    return (tclStubsPtr->tcl_CreateInterp)();
   971         -}
   972         -
   973         -/* Slot 95 */
   974         -void
   975         -Tcl_CreateMathFunc(interp, name, numArgs, argTypes, proc, clientData)
   976         -    Tcl_Interp * interp;
   977         -    char * name;
   978         -    int numArgs;
   979         -    Tcl_ValueType * argTypes;
   980         -    Tcl_MathProc * proc;
   981         -    ClientData clientData;
   982         -{
   983         -    (tclStubsPtr->tcl_CreateMathFunc)(interp, name, numArgs, argTypes, proc, clientData);
   984         -}
   985         -
   986         -/* Slot 96 */
   987         -Tcl_Command
   988         -Tcl_CreateObjCommand(interp, cmdName, proc, clientData, deleteProc)
   989         -    Tcl_Interp * interp;
   990         -    char * cmdName;
   991         -    Tcl_ObjCmdProc * proc;
   992         -    ClientData clientData;
   993         -    Tcl_CmdDeleteProc * deleteProc;
   994         -{
   995         -    return (tclStubsPtr->tcl_CreateObjCommand)(interp, cmdName, proc, clientData, deleteProc);
   996         -}
   997         -
   998         -/* Slot 97 */
   999         -Tcl_Interp *
  1000         -Tcl_CreateSlave(interp, slaveName, isSafe)
  1001         -    Tcl_Interp * interp;
  1002         -    char * slaveName;
  1003         -    int isSafe;
  1004         -{
  1005         -    return (tclStubsPtr->tcl_CreateSlave)(interp, slaveName, isSafe);
  1006         -}
  1007         -
  1008         -/* Slot 98 */
  1009         -Tcl_TimerToken
  1010         -Tcl_CreateTimerHandler(milliseconds, proc, clientData)
  1011         -    int milliseconds;
  1012         -    Tcl_TimerProc * proc;
  1013         -    ClientData clientData;
  1014         -{
  1015         -    return (tclStubsPtr->tcl_CreateTimerHandler)(milliseconds, proc, clientData);
  1016         -}
  1017         -
  1018         -/* Slot 99 */
  1019         -Tcl_Trace
  1020         -Tcl_CreateTrace(interp, level, proc, clientData)
  1021         -    Tcl_Interp * interp;
  1022         -    int level;
  1023         -    Tcl_CmdTraceProc * proc;
  1024         -    ClientData clientData;
  1025         -{
  1026         -    return (tclStubsPtr->tcl_CreateTrace)(interp, level, proc, clientData);
  1027         -}
  1028         -
  1029         -/* Slot 100 */
  1030         -void
  1031         -Tcl_DeleteAssocData(interp, name)
  1032         -    Tcl_Interp * interp;
  1033         -    char * name;
  1034         -{
  1035         -    (tclStubsPtr->tcl_DeleteAssocData)(interp, name);
  1036         -}
  1037         -
  1038         -/* Slot 101 */
  1039         -void
  1040         -Tcl_DeleteChannelHandler(chan, proc, clientData)
  1041         -    Tcl_Channel chan;
  1042         -    Tcl_ChannelProc * proc;
  1043         -    ClientData clientData;
  1044         -{
  1045         -    (tclStubsPtr->tcl_DeleteChannelHandler)(chan, proc, clientData);
  1046         -}
  1047         -
  1048         -/* Slot 102 */
  1049         -void
  1050         -Tcl_DeleteCloseHandler(chan, proc, clientData)
  1051         -    Tcl_Channel chan;
  1052         -    Tcl_CloseProc * proc;
  1053         -    ClientData clientData;
  1054         -{
  1055         -    (tclStubsPtr->tcl_DeleteCloseHandler)(chan, proc, clientData);
  1056         -}
  1057         -
  1058         -/* Slot 103 */
  1059         -int
  1060         -Tcl_DeleteCommand(interp, cmdName)
  1061         -    Tcl_Interp * interp;
  1062         -    char * cmdName;
  1063         -{
  1064         -    return (tclStubsPtr->tcl_DeleteCommand)(interp, cmdName);
  1065         -}
  1066         -
  1067         -/* Slot 104 */
  1068         -int
  1069         -Tcl_DeleteCommandFromToken(interp, command)
  1070         -    Tcl_Interp * interp;
  1071         -    Tcl_Command command;
  1072         -{
  1073         -    return (tclStubsPtr->tcl_DeleteCommandFromToken)(interp, command);
  1074         -}
  1075         -
  1076         -/* Slot 105 */
  1077         -void
  1078         -Tcl_DeleteEvents(proc, clientData)
  1079         -    Tcl_EventDeleteProc * proc;
  1080         -    ClientData clientData;
  1081         -{
  1082         -    (tclStubsPtr->tcl_DeleteEvents)(proc, clientData);
  1083         -}
  1084         -
  1085         -/* Slot 106 */
  1086         -void
  1087         -Tcl_DeleteEventSource(setupProc, checkProc, clientData)
  1088         -    Tcl_EventSetupProc * setupProc;
  1089         -    Tcl_EventCheckProc * checkProc;
  1090         -    ClientData clientData;
  1091         -{
  1092         -    (tclStubsPtr->tcl_DeleteEventSource)(setupProc, checkProc, clientData);
  1093         -}
  1094         -
  1095         -/* Slot 107 */
  1096         -void
  1097         -Tcl_DeleteExitHandler(proc, clientData)
  1098         -    Tcl_ExitProc * proc;
  1099         -    ClientData clientData;
  1100         -{
  1101         -    (tclStubsPtr->tcl_DeleteExitHandler)(proc, clientData);
  1102         -}
  1103         -
  1104         -/* Slot 108 */
  1105         -void
  1106         -Tcl_DeleteHashEntry(entryPtr)
  1107         -    Tcl_HashEntry * entryPtr;
  1108         -{
  1109         -    (tclStubsPtr->tcl_DeleteHashEntry)(entryPtr);
  1110         -}
  1111         -
  1112         -/* Slot 109 */
  1113         -void
  1114         -Tcl_DeleteHashTable(tablePtr)
  1115         -    Tcl_HashTable * tablePtr;
  1116         -{
  1117         -    (tclStubsPtr->tcl_DeleteHashTable)(tablePtr);
  1118         -}
  1119         -
  1120         -/* Slot 110 */
  1121         -void
  1122         -Tcl_DeleteInterp(interp)
  1123         -    Tcl_Interp * interp;
  1124         -{
  1125         -    (tclStubsPtr->tcl_DeleteInterp)(interp);
  1126         -}
  1127         -
  1128         -/* Slot 111 */
  1129         -void
  1130         -Tcl_DetachPids(numPids, pidPtr)
  1131         -    int numPids;
  1132         -    Tcl_Pid * pidPtr;
  1133         -{
  1134         -    (tclStubsPtr->tcl_DetachPids)(numPids, pidPtr);
  1135         -}
  1136         -
  1137         -/* Slot 112 */
  1138         -void
  1139         -Tcl_DeleteTimerHandler(token)
  1140         -    Tcl_TimerToken token;
  1141         -{
  1142         -    (tclStubsPtr->tcl_DeleteTimerHandler)(token);
  1143         -}
  1144         -
  1145         -/* Slot 113 */
  1146         -void
  1147         -Tcl_DeleteTrace(interp, trace)
  1148         -    Tcl_Interp * interp;
  1149         -    Tcl_Trace trace;
  1150         -{
  1151         -    (tclStubsPtr->tcl_DeleteTrace)(interp, trace);
  1152         -}
  1153         -
  1154         -/* Slot 114 */
  1155         -void
  1156         -Tcl_DontCallWhenDeleted(interp, proc, clientData)
  1157         -    Tcl_Interp * interp;
  1158         -    Tcl_InterpDeleteProc * proc;
  1159         -    ClientData clientData;
  1160         -{
  1161         -    (tclStubsPtr->tcl_DontCallWhenDeleted)(interp, proc, clientData);
  1162         -}
  1163         -
  1164         -/* Slot 115 */
  1165         -int
  1166         -Tcl_DoOneEvent(flags)
  1167         -    int flags;
  1168         -{
  1169         -    return (tclStubsPtr->tcl_DoOneEvent)(flags);
  1170         -}
  1171         -
  1172         -/* Slot 116 */
  1173         -void
  1174         -Tcl_DoWhenIdle(proc, clientData)
  1175         -    Tcl_IdleProc * proc;
  1176         -    ClientData clientData;
  1177         -{
  1178         -    (tclStubsPtr->tcl_DoWhenIdle)(proc, clientData);
  1179         -}
  1180         -
  1181         -/* Slot 117 */
  1182         -char *
  1183         -Tcl_DStringAppend(dsPtr, str, length)
  1184         -    Tcl_DString * dsPtr;
  1185         -    CONST char * str;
  1186         -    int length;
  1187         -{
  1188         -    return (tclStubsPtr->tcl_DStringAppend)(dsPtr, str, length);
  1189         -}
  1190         -
  1191         -/* Slot 118 */
  1192         -char *
  1193         -Tcl_DStringAppendElement(dsPtr, string)
  1194         -    Tcl_DString * dsPtr;
  1195         -    CONST char * string;
  1196         -{
  1197         -    return (tclStubsPtr->tcl_DStringAppendElement)(dsPtr, string);
  1198         -}
  1199         -
  1200         -/* Slot 119 */
  1201         -void
  1202         -Tcl_DStringEndSublist(dsPtr)
  1203         -    Tcl_DString * dsPtr;
  1204         -{
  1205         -    (tclStubsPtr->tcl_DStringEndSublist)(dsPtr);
  1206         -}
  1207         -
  1208         -/* Slot 120 */
  1209         -void
  1210         -Tcl_DStringFree(dsPtr)
  1211         -    Tcl_DString * dsPtr;
  1212         -{
  1213         -    (tclStubsPtr->tcl_DStringFree)(dsPtr);
  1214         -}
  1215         -
  1216         -/* Slot 121 */
  1217         -void
  1218         -Tcl_DStringGetResult(interp, dsPtr)
  1219         -    Tcl_Interp * interp;
  1220         -    Tcl_DString * dsPtr;
  1221         -{
  1222         -    (tclStubsPtr->tcl_DStringGetResult)(interp, dsPtr);
  1223         -}
  1224         -
  1225         -/* Slot 122 */
  1226         -void
  1227         -Tcl_DStringInit(dsPtr)
  1228         -    Tcl_DString * dsPtr;
  1229         -{
  1230         -    (tclStubsPtr->tcl_DStringInit)(dsPtr);
  1231         -}
  1232         -
  1233         -/* Slot 123 */
  1234         -void
  1235         -Tcl_DStringResult(interp, dsPtr)
  1236         -    Tcl_Interp * interp;
  1237         -    Tcl_DString * dsPtr;
  1238         -{
  1239         -    (tclStubsPtr->tcl_DStringResult)(interp, dsPtr);
  1240         -}
  1241         -
  1242         -/* Slot 124 */
  1243         -void
  1244         -Tcl_DStringSetLength(dsPtr, length)
  1245         -    Tcl_DString * dsPtr;
  1246         -    int length;
  1247         -{
  1248         -    (tclStubsPtr->tcl_DStringSetLength)(dsPtr, length);
  1249         -}
  1250         -
  1251         -/* Slot 125 */
  1252         -void
  1253         -Tcl_DStringStartSublist(dsPtr)
  1254         -    Tcl_DString * dsPtr;
  1255         -{
  1256         -    (tclStubsPtr->tcl_DStringStartSublist)(dsPtr);
  1257         -}
  1258         -
  1259         -/* Slot 126 */
  1260         -int
  1261         -Tcl_Eof(chan)
  1262         -    Tcl_Channel chan;
  1263         -{
  1264         -    return (tclStubsPtr->tcl_Eof)(chan);
  1265         -}
  1266         -
  1267         -/* Slot 127 */
  1268         -char *
  1269         -Tcl_ErrnoId()
  1270         -{
  1271         -    return (tclStubsPtr->tcl_ErrnoId)();
  1272         -}
  1273         -
  1274         -/* Slot 128 */
  1275         -char *
  1276         -Tcl_ErrnoMsg(err)
  1277         -    int err;
  1278         -{
  1279         -    return (tclStubsPtr->tcl_ErrnoMsg)(err);
  1280         -}
  1281         -
  1282         -/* Slot 129 */
  1283         -int
  1284         -Tcl_Eval(interp, string)
  1285         -    Tcl_Interp * interp;
  1286         -    char * string;
  1287         -{
  1288         -    return (tclStubsPtr->tcl_Eval)(interp, string);
  1289         -}
  1290         -
  1291         -/* Slot 130 */
  1292         -int
  1293         -Tcl_EvalFile(interp, fileName)
  1294         -    Tcl_Interp * interp;
  1295         -    char * fileName;
  1296         -{
  1297         -    return (tclStubsPtr->tcl_EvalFile)(interp, fileName);
  1298         -}
  1299         -
  1300         -/* Slot 131 */
  1301         -int
  1302         -Tcl_EvalObj(interp, objPtr)
  1303         -    Tcl_Interp * interp;
  1304         -    Tcl_Obj * objPtr;
  1305         -{
  1306         -    return (tclStubsPtr->tcl_EvalObj)(interp, objPtr);
  1307         -}
  1308         -
  1309         -/* Slot 132 */
  1310         -void
  1311         -Tcl_EventuallyFree(clientData, freeProc)
  1312         -    ClientData clientData;
  1313         -    Tcl_FreeProc * freeProc;
  1314         -{
  1315         -    (tclStubsPtr->tcl_EventuallyFree)(clientData, freeProc);
  1316         -}
  1317         -
  1318         -/* Slot 133 */
  1319         -void
  1320         -Tcl_Exit(status)
  1321         -    int status;
  1322         -{
  1323         -    (tclStubsPtr->tcl_Exit)(status);
  1324         -}
  1325         -
  1326         -/* Slot 134 */
  1327         -int
  1328         -Tcl_ExposeCommand(interp, hiddenCmdToken, cmdName)
  1329         -    Tcl_Interp * interp;
  1330         -    char * hiddenCmdToken;
  1331         -    char * cmdName;
  1332         -{
  1333         -    return (tclStubsPtr->tcl_ExposeCommand)(interp, hiddenCmdToken, cmdName);
  1334         -}
  1335         -
  1336         -/* Slot 135 */
  1337         -int
  1338         -Tcl_ExprBoolean(interp, str, ptr)
  1339         -    Tcl_Interp * interp;
  1340         -    char * str;
  1341         -    int * ptr;
  1342         -{
  1343         -    return (tclStubsPtr->tcl_ExprBoolean)(interp, str, ptr);
  1344         -}
  1345         -
  1346         -/* Slot 136 */
  1347         -int
  1348         -Tcl_ExprBooleanObj(interp, objPtr, ptr)
  1349         -    Tcl_Interp * interp;
  1350         -    Tcl_Obj * objPtr;
  1351         -    int * ptr;
  1352         -{
  1353         -    return (tclStubsPtr->tcl_ExprBooleanObj)(interp, objPtr, ptr);
  1354         -}
  1355         -
  1356         -/* Slot 137 */
  1357         -int
  1358         -Tcl_ExprDouble(interp, str, ptr)
  1359         -    Tcl_Interp * interp;
  1360         -    char * str;
  1361         -    double * ptr;
  1362         -{
  1363         -    return (tclStubsPtr->tcl_ExprDouble)(interp, str, ptr);
  1364         -}
  1365         -
  1366         -/* Slot 138 */
  1367         -int
  1368         -Tcl_ExprDoubleObj(interp, objPtr, ptr)
  1369         -    Tcl_Interp * interp;
  1370         -    Tcl_Obj * objPtr;
  1371         -    double * ptr;
  1372         -{
  1373         -    return (tclStubsPtr->tcl_ExprDoubleObj)(interp, objPtr, ptr);
  1374         -}
  1375         -
  1376         -/* Slot 139 */
  1377         -int
  1378         -Tcl_ExprLong(interp, str, ptr)
  1379         -    Tcl_Interp * interp;
  1380         -    char * str;
  1381         -    long * ptr;
  1382         -{
  1383         -    return (tclStubsPtr->tcl_ExprLong)(interp, str, ptr);
  1384         -}
  1385         -
  1386         -/* Slot 140 */
  1387         -int
  1388         -Tcl_ExprLongObj(interp, objPtr, ptr)
  1389         -    Tcl_Interp * interp;
  1390         -    Tcl_Obj * objPtr;
  1391         -    long * ptr;
  1392         -{
  1393         -    return (tclStubsPtr->tcl_ExprLongObj)(interp, objPtr, ptr);
  1394         -}
  1395         -
  1396         -/* Slot 141 */
  1397         -int
  1398         -Tcl_ExprObj(interp, objPtr, resultPtrPtr)
  1399         -    Tcl_Interp * interp;
  1400         -    Tcl_Obj * objPtr;
  1401         -    Tcl_Obj ** resultPtrPtr;
  1402         -{
  1403         -    return (tclStubsPtr->tcl_ExprObj)(interp, objPtr, resultPtrPtr);
  1404         -}
  1405         -
  1406         -/* Slot 142 */
  1407         -int
  1408         -Tcl_ExprString(interp, string)
  1409         -    Tcl_Interp * interp;
  1410         -    char * string;
  1411         -{
  1412         -    return (tclStubsPtr->tcl_ExprString)(interp, string);
  1413         -}
  1414         -
  1415         -/* Slot 143 */
  1416         -void
  1417         -Tcl_Finalize()
  1418         -{
  1419         -    (tclStubsPtr->tcl_Finalize)();
  1420         -}
  1421         -
  1422         -/* Slot 144 */
  1423         -void
  1424         -Tcl_FindExecutable(argv0)
  1425         -    CONST char * argv0;
  1426         -{
  1427         -    (tclStubsPtr->tcl_FindExecutable)(argv0);
  1428         -}
  1429         -
  1430         -/* Slot 145 */
  1431         -Tcl_HashEntry *
  1432         -Tcl_FirstHashEntry(tablePtr, searchPtr)
  1433         -    Tcl_HashTable * tablePtr;
  1434         -    Tcl_HashSearch * searchPtr;
  1435         -{
  1436         -    return (tclStubsPtr->tcl_FirstHashEntry)(tablePtr, searchPtr);
  1437         -}
  1438         -
  1439         -/* Slot 146 */
  1440         -int
  1441         -Tcl_Flush(chan)
  1442         -    Tcl_Channel chan;
  1443         -{
  1444         -    return (tclStubsPtr->tcl_Flush)(chan);
  1445         -}
  1446         -
  1447         -/* Slot 147 */
  1448         -void
  1449         -Tcl_FreeResult(interp)
  1450         -    Tcl_Interp * interp;
  1451         -{
  1452         -    (tclStubsPtr->tcl_FreeResult)(interp);
  1453         -}
  1454         -
  1455         -/* Slot 148 */
  1456         -int
  1457         -Tcl_GetAlias(interp, slaveCmd, targetInterpPtr, targetCmdPtr, argcPtr, argvPtr)
  1458         -    Tcl_Interp * interp;
  1459         -    char * slaveCmd;
  1460         -    Tcl_Interp ** targetInterpPtr;
  1461         -    char ** targetCmdPtr;
  1462         -    int * argcPtr;
  1463         -    char *** argvPtr;
  1464         -{
  1465         -    return (tclStubsPtr->tcl_GetAlias)(interp, slaveCmd, targetInterpPtr, targetCmdPtr, argcPtr, argvPtr);
  1466         -}
  1467         -
  1468         -/* Slot 149 */
  1469         -int
  1470         -Tcl_GetAliasObj(interp, slaveCmd, targetInterpPtr, targetCmdPtr, objcPtr, objv)
  1471         -    Tcl_Interp * interp;
  1472         -    char * slaveCmd;
  1473         -    Tcl_Interp ** targetInterpPtr;
  1474         -    char ** targetCmdPtr;
  1475         -    int * objcPtr;
  1476         -    Tcl_Obj *** objv;
  1477         -{
  1478         -    return (tclStubsPtr->tcl_GetAliasObj)(interp, slaveCmd, targetInterpPtr, targetCmdPtr, objcPtr, objv);
  1479         -}
  1480         -
  1481         -/* Slot 150 */
  1482         -ClientData
  1483         -Tcl_GetAssocData(interp, name, procPtr)
  1484         -    Tcl_Interp * interp;
  1485         -    char * name;
  1486         -    Tcl_InterpDeleteProc ** procPtr;
  1487         -{
  1488         -    return (tclStubsPtr->tcl_GetAssocData)(interp, name, procPtr);
  1489         -}
  1490         -
  1491         -/* Slot 151 */
  1492         -Tcl_Channel
  1493         -Tcl_GetChannel(interp, chanName, modePtr)
  1494         -    Tcl_Interp * interp;
  1495         -    char * chanName;
  1496         -    int * modePtr;
  1497         -{
  1498         -    return (tclStubsPtr->tcl_GetChannel)(interp, chanName, modePtr);
  1499         -}
  1500         -
  1501         -/* Slot 152 */
  1502         -int
  1503         -Tcl_GetChannelBufferSize(chan)
  1504         -    Tcl_Channel chan;
  1505         -{
  1506         -    return (tclStubsPtr->tcl_GetChannelBufferSize)(chan);
  1507         -}
  1508         -
  1509         -/* Slot 153 */
  1510         -int
  1511         -Tcl_GetChannelHandle(chan, direction, handlePtr)
  1512         -    Tcl_Channel chan;
  1513         -    int direction;
  1514         -    ClientData * handlePtr;
  1515         -{
  1516         -    return (tclStubsPtr->tcl_GetChannelHandle)(chan, direction, handlePtr);
  1517         -}
  1518         -
  1519         -/* Slot 154 */
  1520         -ClientData
  1521         -Tcl_GetChannelInstanceData(chan)
  1522         -    Tcl_Channel chan;
  1523         -{
  1524         -    return (tclStubsPtr->tcl_GetChannelInstanceData)(chan);
  1525         -}
  1526         -
  1527         -/* Slot 155 */
  1528         -int
  1529         -Tcl_GetChannelMode(chan)
  1530         -    Tcl_Channel chan;
  1531         -{
  1532         -    return (tclStubsPtr->tcl_GetChannelMode)(chan);
  1533         -}
  1534         -
  1535         -/* Slot 156 */
  1536         -char *
  1537         -Tcl_GetChannelName(chan)
  1538         -    Tcl_Channel chan;
  1539         -{
  1540         -    return (tclStubsPtr->tcl_GetChannelName)(chan);
  1541         -}
  1542         -
  1543         -/* Slot 157 */
  1544         -int
  1545         -Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
  1546         -    Tcl_Interp * interp;
  1547         -    Tcl_Channel chan;
  1548         -    char * optionName;
  1549         -    Tcl_DString * dsPtr;
  1550         -{
  1551         -    return (tclStubsPtr->tcl_GetChannelOption)(interp, chan, optionName, dsPtr);
  1552         -}
  1553         -
  1554         -/* Slot 158 */
  1555         -Tcl_ChannelType *
  1556         -Tcl_GetChannelType(chan)
  1557         -    Tcl_Channel chan;
  1558         -{
  1559         -    return (tclStubsPtr->tcl_GetChannelType)(chan);
  1560         -}
  1561         -
  1562         -/* Slot 159 */
  1563         -int
  1564         -Tcl_GetCommandInfo(interp, cmdName, infoPtr)
  1565         -    Tcl_Interp * interp;
  1566         -    char * cmdName;
  1567         -    Tcl_CmdInfo * infoPtr;
  1568         -{
  1569         -    return (tclStubsPtr->tcl_GetCommandInfo)(interp, cmdName, infoPtr);
  1570         -}
  1571         -
  1572         -/* Slot 160 */
  1573         -char *
  1574         -Tcl_GetCommandName(interp, command)
  1575         -    Tcl_Interp * interp;
  1576         -    Tcl_Command command;
  1577         -{
  1578         -    return (tclStubsPtr->tcl_GetCommandName)(interp, command);
  1579         -}
  1580         -
  1581         -/* Slot 161 */
  1582         -int
  1583         -Tcl_GetErrno()
  1584         -{
  1585         -    return (tclStubsPtr->tcl_GetErrno)();
  1586         -}
  1587         -
  1588         -/* Slot 162 */
  1589         -char *
  1590         -Tcl_GetHostName()
  1591         -{
  1592         -    return (tclStubsPtr->tcl_GetHostName)();
  1593         -}
  1594         -
  1595         -/* Slot 163 */
  1596         -int
  1597         -Tcl_GetInterpPath(askInterp, slaveInterp)
  1598         -    Tcl_Interp * askInterp;
  1599         -    Tcl_Interp * slaveInterp;
  1600         -{
  1601         -    return (tclStubsPtr->tcl_GetInterpPath)(askInterp, slaveInterp);
  1602         -}
  1603         -
  1604         -/* Slot 164 */
  1605         -Tcl_Interp *
  1606         -Tcl_GetMaster(interp)
  1607         -    Tcl_Interp * interp;
  1608         -{
  1609         -    return (tclStubsPtr->tcl_GetMaster)(interp);
  1610         -}
  1611         -
  1612         -/* Slot 165 */
  1613         -CONST char *
  1614         -Tcl_GetNameOfExecutable()
  1615         -{
  1616         -    return (tclStubsPtr->tcl_GetNameOfExecutable)();
  1617         -}
  1618         -
  1619         -/* Slot 166 */
  1620         -Tcl_Obj *
  1621         -Tcl_GetObjResult(interp)
  1622         -    Tcl_Interp * interp;
  1623         -{
  1624         -    return (tclStubsPtr->tcl_GetObjResult)(interp);
  1625         -}
  1626         -
  1627         -#if !defined(__WIN32__) && !defined(MAC_TCL) /* UNIX */
  1628         -/* Slot 167 */
  1629         -int
  1630         -Tcl_GetOpenFile(interp, str, write, checkUsage, filePtr)
  1631         -    Tcl_Interp * interp;
  1632         -    char * str;
  1633         -    int write;
  1634         -    int checkUsage;
  1635         -    ClientData * filePtr;
  1636         -{
  1637         -    return (tclStubsPtr->tcl_GetOpenFile)(interp, str, write, checkUsage, filePtr);
  1638         -}
  1639         -
  1640         -#endif /* UNIX */
  1641         -/* Slot 168 */
  1642         -Tcl_PathType
  1643         -Tcl_GetPathType(path)
  1644         -    char * path;
  1645         -{
  1646         -    return (tclStubsPtr->tcl_GetPathType)(path);
  1647         -}
  1648         -
  1649         -/* Slot 169 */
  1650         -int
  1651         -Tcl_Gets(chan, dsPtr)
  1652         -    Tcl_Channel chan;
  1653         -    Tcl_DString * dsPtr;
  1654         -{
  1655         -    return (tclStubsPtr->tcl_Gets)(chan, dsPtr);
  1656         -}
  1657         -
  1658         -/* Slot 170 */
  1659         -int
  1660         -Tcl_GetsObj(chan, objPtr)
  1661         -    Tcl_Channel chan;
  1662         -    Tcl_Obj * objPtr;
  1663         -{
  1664         -    return (tclStubsPtr->tcl_GetsObj)(chan, objPtr);
  1665         -}
  1666         -
  1667         -/* Slot 171 */
  1668         -int
  1669         -Tcl_GetServiceMode()
  1670         -{
  1671         -    return (tclStubsPtr->tcl_GetServiceMode)();
  1672         -}
  1673         -
  1674         -/* Slot 172 */
  1675         -Tcl_Interp *
  1676         -Tcl_GetSlave(interp, slaveName)
  1677         -    Tcl_Interp * interp;
  1678         -    char * slaveName;
  1679         -{
  1680         -    return (tclStubsPtr->tcl_GetSlave)(interp, slaveName);
  1681         -}
  1682         -
  1683         -/* Slot 173 */
  1684         -Tcl_Channel
  1685         -Tcl_GetStdChannel(type)
  1686         -    int type;
  1687         -{
  1688         -    return (tclStubsPtr->tcl_GetStdChannel)(type);
  1689         -}
  1690         -
  1691         -/* Slot 174 */
  1692         -char *
  1693         -Tcl_GetStringResult(interp)
  1694         -    Tcl_Interp * interp;
  1695         -{
  1696         -    return (tclStubsPtr->tcl_GetStringResult)(interp);
  1697         -}
  1698         -
  1699         -/* Slot 175 */
  1700         -char *
  1701         -Tcl_GetVar(interp, varName, flags)
  1702         -    Tcl_Interp * interp;
  1703         -    char * varName;
  1704         -    int flags;
  1705         -{
  1706         -    return (tclStubsPtr->tcl_GetVar)(interp, varName, flags);
  1707         -}
  1708         -
  1709         -/* Slot 176 */
  1710         -char *
  1711         -Tcl_GetVar2(interp, part1, part2, flags)
  1712         -    Tcl_Interp * interp;
  1713         -    char * part1;
  1714         -    char * part2;
  1715         -    int flags;
  1716         -{
  1717         -    return (tclStubsPtr->tcl_GetVar2)(interp, part1, part2, flags);
  1718         -}
  1719         -
  1720         -/* Slot 177 */
  1721         -int
  1722         -Tcl_GlobalEval(interp, command)
  1723         -    Tcl_Interp * interp;
  1724         -    char * command;
  1725         -{
  1726         -    return (tclStubsPtr->tcl_GlobalEval)(interp, command);
  1727         -}
  1728         -
  1729         -/* Slot 178 */
  1730         -int
  1731         -Tcl_GlobalEvalObj(interp, objPtr)
  1732         -    Tcl_Interp * interp;
  1733         -    Tcl_Obj * objPtr;
  1734         -{
  1735         -    return (tclStubsPtr->tcl_GlobalEvalObj)(interp, objPtr);
  1736         -}
  1737         -
  1738         -/* Slot 179 */
  1739         -int
  1740         -Tcl_HideCommand(interp, cmdName, hiddenCmdToken)
  1741         -    Tcl_Interp * interp;
  1742         -    char * cmdName;
  1743         -    char * hiddenCmdToken;
  1744         -{
  1745         -    return (tclStubsPtr->tcl_HideCommand)(interp, cmdName, hiddenCmdToken);
  1746         -}
  1747         -
  1748         -/* Slot 180 */
  1749         -int
  1750         -Tcl_Init(interp)
  1751         -    Tcl_Interp * interp;
  1752         -{
  1753         -    return (tclStubsPtr->tcl_Init)(interp);
  1754         -}
  1755         -
  1756         -/* Slot 181 */
  1757         -void
  1758         -Tcl_InitHashTable(tablePtr, keyType)
  1759         -    Tcl_HashTable * tablePtr;
  1760         -    int keyType;
  1761         -{
  1762         -    (tclStubsPtr->tcl_InitHashTable)(tablePtr, keyType);
  1763         -}
  1764         -
  1765         -/* Slot 182 */
  1766         -int
  1767         -Tcl_InputBlocked(chan)
  1768         -    Tcl_Channel chan;
  1769         -{
  1770         -    return (tclStubsPtr->tcl_InputBlocked)(chan);
  1771         -}
  1772         -
  1773         -/* Slot 183 */
  1774         -int
  1775         -Tcl_InputBuffered(chan)
  1776         -    Tcl_Channel chan;
  1777         -{
  1778         -    return (tclStubsPtr->tcl_InputBuffered)(chan);
  1779         -}
  1780         -
  1781         -/* Slot 184 */
  1782         -int
  1783         -Tcl_InterpDeleted(interp)
  1784         -    Tcl_Interp * interp;
  1785         -{
  1786         -    return (tclStubsPtr->tcl_InterpDeleted)(interp);
  1787         -}
  1788         -
  1789         -/* Slot 185 */
  1790         -int
  1791         -Tcl_IsSafe(interp)
  1792         -    Tcl_Interp * interp;
  1793         -{
  1794         -    return (tclStubsPtr->tcl_IsSafe)(interp);
  1795         -}
  1796         -
  1797         -/* Slot 186 */
  1798         -char *
  1799         -Tcl_JoinPath(argc, argv, resultPtr)
  1800         -    int argc;
  1801         -    char ** argv;
  1802         -    Tcl_DString * resultPtr;
  1803         -{
  1804         -    return (tclStubsPtr->tcl_JoinPath)(argc, argv, resultPtr);
  1805         -}
  1806         -
  1807         -/* Slot 187 */
  1808         -int
  1809         -Tcl_LinkVar(interp, varName, addr, type)
  1810         -    Tcl_Interp * interp;
  1811         -    char * varName;
  1812         -    char * addr;
  1813         -    int type;
  1814         -{
  1815         -    return (tclStubsPtr->tcl_LinkVar)(interp, varName, addr, type);
  1816         -}
  1817         -
  1818         -/* Slot 188 is reserved */
  1819         -/* Slot 189 */
  1820         -Tcl_Channel
  1821         -Tcl_MakeFileChannel(handle, mode)
  1822         -    ClientData handle;
  1823         -    int mode;
  1824         -{
  1825         -    return (tclStubsPtr->tcl_MakeFileChannel)(handle, mode);
  1826         -}
  1827         -
  1828         -/* Slot 190 */
  1829         -int
  1830         -Tcl_MakeSafe(interp)
  1831         -    Tcl_Interp * interp;
  1832         -{
  1833         -    return (tclStubsPtr->tcl_MakeSafe)(interp);
  1834         -}
  1835         -
  1836         -/* Slot 191 */
  1837         -Tcl_Channel
  1838         -Tcl_MakeTcpClientChannel(tcpSocket)
  1839         -    ClientData tcpSocket;
  1840         -{
  1841         -    return (tclStubsPtr->tcl_MakeTcpClientChannel)(tcpSocket);
  1842         -}
  1843         -
  1844         -/* Slot 192 */
  1845         -char *
  1846         -Tcl_Merge(argc, argv)
  1847         -    int argc;
  1848         -    char ** argv;
  1849         -{
  1850         -    return (tclStubsPtr->tcl_Merge)(argc, argv);
  1851         -}
  1852         -
  1853         -/* Slot 193 */
  1854         -Tcl_HashEntry *
  1855         -Tcl_NextHashEntry(searchPtr)
  1856         -    Tcl_HashSearch * searchPtr;
  1857         -{
  1858         -    return (tclStubsPtr->tcl_NextHashEntry)(searchPtr);
  1859         -}
  1860         -
  1861         -/* Slot 194 */
  1862         -void
  1863         -Tcl_NotifyChannel(channel, mask)
  1864         -    Tcl_Channel channel;
  1865         -    int mask;
  1866         -{
  1867         -    (tclStubsPtr->tcl_NotifyChannel)(channel, mask);
  1868         -}
  1869         -
  1870         -/* Slot 195 */
  1871         -Tcl_Obj *
  1872         -Tcl_ObjGetVar2(interp, part1Ptr, part2Ptr, flags)
  1873         -    Tcl_Interp * interp;
  1874         -    Tcl_Obj * part1Ptr;
  1875         -    Tcl_Obj * part2Ptr;
  1876         -    int flags;
  1877         -{
  1878         -    return (tclStubsPtr->tcl_ObjGetVar2)(interp, part1Ptr, part2Ptr, flags);
  1879         -}
  1880         -
  1881         -/* Slot 196 */
  1882         -Tcl_Obj *
  1883         -Tcl_ObjSetVar2(interp, part1Ptr, part2Ptr, newValuePtr, flags)
  1884         -    Tcl_Interp * interp;
  1885         -    Tcl_Obj * part1Ptr;
  1886         -    Tcl_Obj * part2Ptr;
  1887         -    Tcl_Obj * newValuePtr;
  1888         -    int flags;
  1889         -{
  1890         -    return (tclStubsPtr->tcl_ObjSetVar2)(interp, part1Ptr, part2Ptr, newValuePtr, flags);
  1891         -}
  1892         -
  1893         -/* Slot 197 */
  1894         -Tcl_Channel
  1895         -Tcl_OpenCommandChannel(interp, argc, argv, flags)
  1896         -    Tcl_Interp * interp;
  1897         -    int argc;
  1898         -    char ** argv;
  1899         -    int flags;
  1900         -{
  1901         -    return (tclStubsPtr->tcl_OpenCommandChannel)(interp, argc, argv, flags);
  1902         -}
  1903         -
  1904         -/* Slot 198 */
  1905         -Tcl_Channel
  1906         -Tcl_OpenFileChannel(interp, fileName, modeString, permissions)
  1907         -    Tcl_Interp * interp;
  1908         -    char * fileName;
  1909         -    char * modeString;
  1910         -    int permissions;
  1911         -{
  1912         -    return (tclStubsPtr->tcl_OpenFileChannel)(interp, fileName, modeString, permissions);
  1913         -}
  1914         -
  1915         -/* Slot 199 */
  1916         -Tcl_Channel
  1917         -Tcl_OpenTcpClient(interp, port, address, myaddr, myport, async)
  1918         -    Tcl_Interp * interp;
  1919         -    int port;
  1920         -    char * address;
  1921         -    char * myaddr;
  1922         -    int myport;
  1923         -    int async;
  1924         -{
  1925         -    return (tclStubsPtr->tcl_OpenTcpClient)(interp, port, address, myaddr, myport, async);
  1926         -}
  1927         -
  1928         -/* Slot 200 */
  1929         -Tcl_Channel
  1930         -Tcl_OpenTcpServer(interp, port, host, acceptProc, callbackData)
  1931         -    Tcl_Interp * interp;
  1932         -    int port;
  1933         -    char * host;
  1934         -    Tcl_TcpAcceptProc * acceptProc;
  1935         -    ClientData callbackData;
  1936         -{
  1937         -    return (tclStubsPtr->tcl_OpenTcpServer)(interp, port, host, acceptProc, callbackData);
  1938         -}
  1939         -
  1940         -/* Slot 201 */
  1941         -void
  1942         -Tcl_Preserve(data)
  1943         -    ClientData data;
  1944         -{
  1945         -    (tclStubsPtr->tcl_Preserve)(data);
  1946         -}
  1947         -
  1948         -/* Slot 202 */
  1949         -void
  1950         -Tcl_PrintDouble(interp, value, dst)
  1951         -    Tcl_Interp * interp;
  1952         -    double value;
  1953         -    char * dst;
  1954         -{
  1955         -    (tclStubsPtr->tcl_PrintDouble)(interp, value, dst);
  1956         -}
  1957         -
  1958         -/* Slot 203 */
  1959         -int
  1960         -Tcl_PutEnv(string)
  1961         -    CONST char * string;
  1962         -{
  1963         -    return (tclStubsPtr->tcl_PutEnv)(string);
  1964         -}
  1965         -
  1966         -/* Slot 204 */
  1967         -char *
  1968         -Tcl_PosixError(interp)
  1969         -    Tcl_Interp * interp;
  1970         -{
  1971         -    return (tclStubsPtr->tcl_PosixError)(interp);
  1972         -}
  1973         -
  1974         -/* Slot 205 */
  1975         -void
  1976         -Tcl_QueueEvent(evPtr, position)
  1977         -    Tcl_Event * evPtr;
  1978         -    Tcl_QueuePosition position;
  1979         -{
  1980         -    (tclStubsPtr->tcl_QueueEvent)(evPtr, position);
  1981         -}
  1982         -
  1983         -/* Slot 206 */
  1984         -int
  1985         -Tcl_Read(chan, bufPtr, toRead)
  1986         -    Tcl_Channel chan;
  1987         -    char * bufPtr;
  1988         -    int toRead;
  1989         -{
  1990         -    return (tclStubsPtr->tcl_Read)(chan, bufPtr, toRead);
  1991         -}
  1992         -
  1993         -/* Slot 207 */
  1994         -void
  1995         -Tcl_ReapDetachedProcs()
  1996         -{
  1997         -    (tclStubsPtr->tcl_ReapDetachedProcs)();
  1998         -}
  1999         -
  2000         -/* Slot 208 */
  2001         -int
  2002         -Tcl_RecordAndEval(interp, cmd, flags)
  2003         -    Tcl_Interp * interp;
  2004         -    char * cmd;
  2005         -    int flags;
  2006         -{
  2007         -    return (tclStubsPtr->tcl_RecordAndEval)(interp, cmd, flags);
  2008         -}
  2009         -
  2010         -/* Slot 209 */
  2011         -int
  2012         -Tcl_RecordAndEvalObj(interp, cmdPtr, flags)
  2013         -    Tcl_Interp * interp;
  2014         -    Tcl_Obj * cmdPtr;
  2015         -    int flags;
  2016         -{
  2017         -    return (tclStubsPtr->tcl_RecordAndEvalObj)(interp, cmdPtr, flags);
  2018         -}
  2019         -
  2020         -/* Slot 210 */
  2021         -void
  2022         -Tcl_RegisterChannel(interp, chan)
  2023         -    Tcl_Interp * interp;
  2024         -    Tcl_Channel chan;
  2025         -{
  2026         -    (tclStubsPtr->tcl_RegisterChannel)(interp, chan);
  2027         -}
  2028         -
  2029         -/* Slot 211 */
  2030         -void
  2031         -Tcl_RegisterObjType(typePtr)
  2032         -    Tcl_ObjType * typePtr;
  2033         -{
  2034         -    (tclStubsPtr->tcl_RegisterObjType)(typePtr);
  2035         -}
  2036         -
  2037         -/* Slot 212 */
  2038         -Tcl_RegExp
  2039         -Tcl_RegExpCompile(interp, string)
  2040         -    Tcl_Interp * interp;
  2041         -    char * string;
  2042         -{
  2043         -    return (tclStubsPtr->tcl_RegExpCompile)(interp, string);
  2044         -}
  2045         -
  2046         -/* Slot 213 */
  2047         -int
  2048         -Tcl_RegExpExec(interp, regexp, str, start)
  2049         -    Tcl_Interp * interp;
  2050         -    Tcl_RegExp regexp;
  2051         -    CONST char * str;
  2052         -    CONST char * start;
  2053         -{
  2054         -    return (tclStubsPtr->tcl_RegExpExec)(interp, regexp, str, start);
  2055         -}
  2056         -
  2057         -/* Slot 214 */
  2058         -int
  2059         -Tcl_RegExpMatch(interp, str, pattern)
  2060         -    Tcl_Interp * interp;
  2061         -    char * str;
  2062         -    char * pattern;
  2063         -{
  2064         -    return (tclStubsPtr->tcl_RegExpMatch)(interp, str, pattern);
  2065         -}
  2066         -
  2067         -/* Slot 215 */
  2068         -void
  2069         -Tcl_RegExpRange(regexp, index, startPtr, endPtr)
  2070         -    Tcl_RegExp regexp;
  2071         -    int index;
  2072         -    char ** startPtr;
  2073         -    char ** endPtr;
  2074         -{
  2075         -    (tclStubsPtr->tcl_RegExpRange)(regexp, index, startPtr, endPtr);
  2076         -}
  2077         -
  2078         -/* Slot 216 */
  2079         -void
  2080         -Tcl_Release(clientData)
  2081         -    ClientData clientData;
  2082         -{
  2083         -    (tclStubsPtr->tcl_Release)(clientData);
  2084         -}
  2085         -
  2086         -/* Slot 217 */
  2087         -void
  2088         -Tcl_ResetResult(interp)
  2089         -    Tcl_Interp * interp;
  2090         -{
  2091         -    (tclStubsPtr->tcl_ResetResult)(interp);
  2092         -}
  2093         -
  2094         -/* Slot 218 */
  2095         -int
  2096         -Tcl_ScanElement(str, flagPtr)
  2097         -    CONST char * str;
  2098         -    int * flagPtr;
  2099         -{
  2100         -    return (tclStubsPtr->tcl_ScanElement)(str, flagPtr);
  2101         -}
  2102         -
  2103         -/* Slot 219 */
  2104         -int
  2105         -Tcl_ScanCountedElement(str, length, flagPtr)
  2106         -    CONST char * str;
  2107         -    int length;
  2108         -    int * flagPtr;
  2109         -{
  2110         -    return (tclStubsPtr->tcl_ScanCountedElement)(str, length, flagPtr);
  2111         -}
  2112         -
  2113         -/* Slot 220 */
  2114         -int
  2115         -Tcl_Seek(chan, offset, mode)
  2116         -    Tcl_Channel chan;
  2117         -    int offset;
  2118         -    int mode;
  2119         -{
  2120         -    return (tclStubsPtr->tcl_Seek)(chan, offset, mode);
  2121         -}
  2122         -
  2123         -/* Slot 221 */
  2124         -int
  2125         -Tcl_ServiceAll()
  2126         -{
  2127         -    return (tclStubsPtr->tcl_ServiceAll)();
  2128         -}
  2129         -
  2130         -/* Slot 222 */
  2131         -int
  2132         -Tcl_ServiceEvent(flags)
  2133         -    int flags;
  2134         -{
  2135         -    return (tclStubsPtr->tcl_ServiceEvent)(flags);
  2136         -}
  2137         -
  2138         -/* Slot 223 */
  2139         -void
  2140         -Tcl_SetAssocData(interp, name, proc, clientData)
  2141         -    Tcl_Interp * interp;
  2142         -    char * name;
  2143         -    Tcl_InterpDeleteProc * proc;
  2144         -    ClientData clientData;
  2145         -{
  2146         -    (tclStubsPtr->tcl_SetAssocData)(interp, name, proc, clientData);
  2147         -}
  2148         -
  2149         -/* Slot 224 */
  2150         -void
  2151         -Tcl_SetChannelBufferSize(chan, sz)
  2152         -    Tcl_Channel chan;
  2153         -    int sz;
  2154         -{
  2155         -    (tclStubsPtr->tcl_SetChannelBufferSize)(chan, sz);
  2156         -}
  2157         -
  2158         -/* Slot 225 */
  2159         -int
  2160         -Tcl_SetChannelOption(interp, chan, optionName, newValue)
  2161         -    Tcl_Interp * interp;
  2162         -    Tcl_Channel chan;
  2163         -    char * optionName;
  2164         -    char * newValue;
  2165         -{
  2166         -    return (tclStubsPtr->tcl_SetChannelOption)(interp, chan, optionName, newValue);
  2167         -}
  2168         -
  2169         -/* Slot 226 */
  2170         -int
  2171         -Tcl_SetCommandInfo(interp, cmdName, infoPtr)
  2172         -    Tcl_Interp * interp;
  2173         -    char * cmdName;
  2174         -    Tcl_CmdInfo * infoPtr;
  2175         -{
  2176         -    return (tclStubsPtr->tcl_SetCommandInfo)(interp, cmdName, infoPtr);
  2177         -}
  2178         -
  2179         -/* Slot 227 */
  2180         -void
  2181         -Tcl_SetErrno(err)
  2182         -    int err;
  2183         -{
  2184         -    (tclStubsPtr->tcl_SetErrno)(err);
  2185         -}
  2186         -
  2187         -/* Slot 228 */
  2188         -void
  2189         -Tcl_SetErrorCode TCL_VARARGS_DEF(Tcl_Interp *,interp)
  2190         -{
  2191         -    Tcl_Interp * var;
  2192         -    va_list argList;
  2193         -
  2194         -    var = (Tcl_Interp *) TCL_VARARGS_START(Tcl_Interp *,interp,argList);
  2195         -
  2196         -    (tclStubsPtr->tcl_SetErrorCodeVA)(var, argList);
  2197         -    va_end(argList);
  2198         -}
  2199         -
  2200         -/* Slot 229 */
  2201         -void
  2202         -Tcl_SetMaxBlockTime(timePtr)
  2203         -    Tcl_Time * timePtr;
  2204         -{
  2205         -    (tclStubsPtr->tcl_SetMaxBlockTime)(timePtr);
  2206         -}
  2207         -
  2208         -/* Slot 230 */
  2209         -void
  2210         -Tcl_SetPanicProc(panicProc)
  2211         -    Tcl_PanicProc * panicProc;
  2212         -{
  2213         -    (tclStubsPtr->tcl_SetPanicProc)(panicProc);
  2214         -}
  2215         -
  2216         -/* Slot 231 */
  2217         -int
  2218         -Tcl_SetRecursionLimit(interp, depth)
  2219         -    Tcl_Interp * interp;
  2220         -    int depth;
  2221         -{
  2222         -    return (tclStubsPtr->tcl_SetRecursionLimit)(interp, depth);
  2223         -}
  2224         -
  2225         -/* Slot 232 */
  2226         -void
  2227         -Tcl_SetResult(interp, str, freeProc)
  2228         -    Tcl_Interp * interp;
  2229         -    char * str;
  2230         -    Tcl_FreeProc * freeProc;
  2231         -{
  2232         -    (tclStubsPtr->tcl_SetResult)(interp, str, freeProc);
  2233         -}
  2234         -
  2235         -/* Slot 233 */
  2236         -int
  2237         -Tcl_SetServiceMode(mode)
  2238         -    int mode;
  2239         -{
  2240         -    return (tclStubsPtr->tcl_SetServiceMode)(mode);
  2241         -}
  2242         -
  2243         -/* Slot 234 */
  2244         -void
  2245         -Tcl_SetObjErrorCode(interp, errorObjPtr)
  2246         -    Tcl_Interp * interp;
  2247         -    Tcl_Obj * errorObjPtr;
  2248         -{
  2249         -    (tclStubsPtr->tcl_SetObjErrorCode)(interp, errorObjPtr);
  2250         -}
  2251         -
  2252         -/* Slot 235 */
  2253         -void
  2254         -Tcl_SetObjResult(interp, resultObjPtr)
  2255         -    Tcl_Interp * interp;
  2256         -    Tcl_Obj * resultObjPtr;
  2257         -{
  2258         -    (tclStubsPtr->tcl_SetObjResult)(interp, resultObjPtr);
  2259         -}
  2260         -
  2261         -/* Slot 236 */
  2262         -void
  2263         -Tcl_SetStdChannel(channel, type)
  2264         -    Tcl_Channel channel;
  2265         -    int type;
  2266         -{
  2267         -    (tclStubsPtr->tcl_SetStdChannel)(channel, type);
  2268         -}
  2269         -
  2270         -/* Slot 237 */
  2271         -char *
  2272         -Tcl_SetVar(interp, varName, newValue, flags)
  2273         -    Tcl_Interp * interp;
  2274         -    char * varName;
  2275         -    char * newValue;
  2276         -    int flags;
  2277         -{
  2278         -    return (tclStubsPtr->tcl_SetVar)(interp, varName, newValue, flags);
  2279         -}
  2280         -
  2281         -/* Slot 238 */
  2282         -char *
  2283         -Tcl_SetVar2(interp, part1, part2, newValue, flags)
  2284         -    Tcl_Interp * interp;
  2285         -    char * part1;
  2286         -    char * part2;
  2287         -    char * newValue;
  2288         -    int flags;
  2289         -{
  2290         -    return (tclStubsPtr->tcl_SetVar2)(interp, part1, part2, newValue, flags);
  2291         -}
  2292         -
  2293         -/* Slot 239 */
  2294         -char *
  2295         -Tcl_SignalId(sig)
  2296         -    int sig;
  2297         -{
  2298         -    return (tclStubsPtr->tcl_SignalId)(sig);
  2299         -}
  2300         -
  2301         -/* Slot 240 */
  2302         -char *
  2303         -Tcl_SignalMsg(sig)
  2304         -    int sig;
  2305         -{
  2306         -    return (tclStubsPtr->tcl_SignalMsg)(sig);
  2307         -}
  2308         -
  2309         -/* Slot 241 */
  2310         -void
  2311         -Tcl_SourceRCFile(interp)
  2312         -    Tcl_Interp * interp;
  2313         -{
  2314         -    (tclStubsPtr->tcl_SourceRCFile)(interp);
  2315         -}
  2316         -
  2317         -/* Slot 242 */
  2318         -int
  2319         -Tcl_SplitList(interp, listStr, argcPtr, argvPtr)
  2320         -    Tcl_Interp * interp;
  2321         -    CONST char * listStr;
  2322         -    int * argcPtr;
  2323         -    char *** argvPtr;
  2324         -{
  2325         -    return (tclStubsPtr->tcl_SplitList)(interp, listStr, argcPtr, argvPtr);
  2326         -}
  2327         -
  2328         -/* Slot 243 */
  2329         -void
  2330         -Tcl_SplitPath(path, argcPtr, argvPtr)
  2331         -    CONST char * path;
  2332         -    int * argcPtr;
  2333         -    char *** argvPtr;
  2334         -{
  2335         -    (tclStubsPtr->tcl_SplitPath)(path, argcPtr, argvPtr);
  2336         -}
  2337         -
  2338         -/* Slot 244 */
  2339         -void
  2340         -Tcl_StaticPackage(interp, pkgName, initProc, safeInitProc)
  2341         -    Tcl_Interp * interp;
  2342         -    char * pkgName;
  2343         -    Tcl_PackageInitProc * initProc;
  2344         -    Tcl_PackageInitProc * safeInitProc;
  2345         -{
  2346         -    (tclStubsPtr->tcl_StaticPackage)(interp, pkgName, initProc, safeInitProc);
  2347         -}
  2348         -
  2349         -/* Slot 245 */
  2350         -int
  2351         -Tcl_StringMatch(str, pattern)
  2352         -    CONST char * str;
  2353         -    CONST char * pattern;
  2354         -{
  2355         -    return (tclStubsPtr->tcl_StringMatch)(str, pattern);
  2356         -}
  2357         -
  2358         -/* Slot 246 */
  2359         -int
  2360         -Tcl_Tell(chan)
  2361         -    Tcl_Channel chan;
  2362         -{
  2363         -    return (tclStubsPtr->tcl_Tell)(chan);
  2364         -}
  2365         -
  2366         -/* Slot 247 */
  2367         -int
  2368         -Tcl_TraceVar(interp, varName, flags, proc, clientData)
  2369         -    Tcl_Interp * interp;
  2370         -    char * varName;
  2371         -    int flags;
  2372         -    Tcl_VarTraceProc * proc;
  2373         -    ClientData clientData;
  2374         -{
  2375         -    return (tclStubsPtr->tcl_TraceVar)(interp, varName, flags, proc, clientData);
  2376         -}
  2377         -
  2378         -/* Slot 248 */
  2379         -int
  2380         -Tcl_TraceVar2(interp, part1, part2, flags, proc, clientData)
  2381         -    Tcl_Interp * interp;
  2382         -    char * part1;
  2383         -    char * part2;
  2384         -    int flags;
  2385         -    Tcl_VarTraceProc * proc;
  2386         -    ClientData clientData;
  2387         -{
  2388         -    return (tclStubsPtr->tcl_TraceVar2)(interp, part1, part2, flags, proc, clientData);
  2389         -}
  2390         -
  2391         -/* Slot 249 */
  2392         -char *
  2393         -Tcl_TranslateFileName(interp, name, bufferPtr)
  2394         -    Tcl_Interp * interp;
  2395         -    char * name;
  2396         -    Tcl_DString * bufferPtr;
  2397         -{
  2398         -    return (tclStubsPtr->tcl_TranslateFileName)(interp, name, bufferPtr);
  2399         -}
  2400         -
  2401         -/* Slot 250 */
  2402         -int
  2403         -Tcl_Ungets(chan, str, len, atHead)
  2404         -    Tcl_Channel chan;
  2405         -    char * str;
  2406         -    int len;
  2407         -    int atHead;
  2408         -{
  2409         -    return (tclStubsPtr->tcl_Ungets)(chan, str, len, atHead);
  2410         -}
  2411         -
  2412         -/* Slot 251 */
  2413         -void
  2414         -Tcl_UnlinkVar(interp, varName)
  2415         -    Tcl_Interp * interp;
  2416         -    char * varName;
  2417         -{
  2418         -    (tclStubsPtr->tcl_UnlinkVar)(interp, varName);
  2419         -}
  2420         -
  2421         -/* Slot 252 */
  2422         -int
  2423         -Tcl_UnregisterChannel(interp, chan)
  2424         -    Tcl_Interp * interp;
  2425         -    Tcl_Channel chan;
  2426         -{
  2427         -    return (tclStubsPtr->tcl_UnregisterChannel)(interp, chan);
  2428         -}
  2429         -
  2430         -/* Slot 253 */
  2431         -int
  2432         -Tcl_UnsetVar(interp, varName, flags)
  2433         -    Tcl_Interp * interp;
  2434         -    char * varName;
  2435         -    int flags;
  2436         -{
  2437         -    return (tclStubsPtr->tcl_UnsetVar)(interp, varName, flags);
  2438         -}
  2439         -
  2440         -/* Slot 254 */
  2441         -int
  2442         -Tcl_UnsetVar2(interp, part1, part2, flags)
  2443         -    Tcl_Interp * interp;
  2444         -    char * part1;
  2445         -    char * part2;
  2446         -    int flags;
  2447         -{
  2448         -    return (tclStubsPtr->tcl_UnsetVar2)(interp, part1, part2, flags);
  2449         -}
  2450         -
  2451         -/* Slot 255 */
  2452         -void
  2453         -Tcl_UntraceVar(interp, varName, flags, proc, clientData)
  2454         -    Tcl_Interp * interp;
  2455         -    char * varName;
  2456         -    int flags;
  2457         -    Tcl_VarTraceProc * proc;
  2458         -    ClientData clientData;
  2459         -{
  2460         -    (tclStubsPtr->tcl_UntraceVar)(interp, varName, flags, proc, clientData);
  2461         -}
  2462         -
  2463         -/* Slot 256 */
  2464         -void
  2465         -Tcl_UntraceVar2(interp, part1, part2, flags, proc, clientData)
  2466         -    Tcl_Interp * interp;
  2467         -    char * part1;
  2468         -    char * part2;
  2469         -    int flags;
  2470         -    Tcl_VarTraceProc * proc;
  2471         -    ClientData clientData;
  2472         -{
  2473         -    (tclStubsPtr->tcl_UntraceVar2)(interp, part1, part2, flags, proc, clientData);
  2474         -}
  2475         -
  2476         -/* Slot 257 */
  2477         -void
  2478         -Tcl_UpdateLinkedVar(interp, varName)
  2479         -    Tcl_Interp * interp;
  2480         -    char * varName;
  2481         -{
  2482         -    (tclStubsPtr->tcl_UpdateLinkedVar)(interp, varName);
  2483         -}
  2484         -
  2485         -/* Slot 258 */
  2486         -int
  2487         -Tcl_UpVar(interp, frameName, varName, localName, flags)
  2488         -    Tcl_Interp * interp;
  2489         -    char * frameName;
  2490         -    char * varName;
  2491         -    char * localName;
  2492         -    int flags;
  2493         -{
  2494         -    return (tclStubsPtr->tcl_UpVar)(interp, frameName, varName, localName, flags);
  2495         -}
  2496         -
  2497         -/* Slot 259 */
  2498         -int
  2499         -Tcl_UpVar2(interp, frameName, part1, part2, localName, flags)
  2500         -    Tcl_Interp * interp;
  2501         -    char * frameName;
  2502         -    char * part1;
  2503         -    char * part2;
  2504         -    char * localName;
  2505         -    int flags;
  2506         -{
  2507         -    return (tclStubsPtr->tcl_UpVar2)(interp, frameName, part1, part2, localName, flags);
  2508         -}
  2509         -
  2510         -/* Slot 260 */
  2511         -int
  2512         -Tcl_VarEval TCL_VARARGS_DEF(Tcl_Interp *,interp)
  2513         -{
  2514         -    Tcl_Interp * var;
  2515         -    va_list argList;
  2516         -    int resultValue;
  2517         -
  2518         -    var = (Tcl_Interp *) TCL_VARARGS_START(Tcl_Interp *,interp,argList);
  2519         -
  2520         -    resultValue = (tclStubsPtr->tcl_VarEvalVA)(var, argList);
  2521         -    va_end(argList);
  2522         -return resultValue;
  2523         -}
  2524         -
  2525         -/* Slot 261 */
  2526         -ClientData
  2527         -Tcl_VarTraceInfo(interp, varName, flags, procPtr, prevClientData)
  2528         -    Tcl_Interp * interp;
  2529         -    char * varName;
  2530         -    int flags;
  2531         -    Tcl_VarTraceProc * procPtr;
  2532         -    ClientData prevClientData;
  2533         -{
  2534         -    return (tclStubsPtr->tcl_VarTraceInfo)(interp, varName, flags, procPtr, prevClientData);
  2535         -}
  2536         -
  2537         -/* Slot 262 */
  2538         -ClientData
  2539         -Tcl_VarTraceInfo2(interp, part1, part2, flags, procPtr, prevClientData)
  2540         -    Tcl_Interp * interp;
  2541         -    char * part1;
  2542         -    char * part2;
  2543         -    int flags;
  2544         -    Tcl_VarTraceProc * procPtr;
  2545         -    ClientData prevClientData;
  2546         -{
  2547         -    return (tclStubsPtr->tcl_VarTraceInfo2)(interp, part1, part2, flags, procPtr, prevClientData);
  2548         -}
  2549         -
  2550         -/* Slot 263 */
  2551         -int
  2552         -Tcl_Write(chan, s, slen)
  2553         -    Tcl_Channel chan;
  2554         -    char * s;
  2555         -    int slen;
  2556         -{
  2557         -    return (tclStubsPtr->tcl_Write)(chan, s, slen);
  2558         -}
  2559         -
  2560         -/* Slot 264 */
  2561         -void
  2562         -Tcl_WrongNumArgs(interp, objc, objv, message)
  2563         -    Tcl_Interp * interp;
  2564         -    int objc;
  2565         -    Tcl_Obj *CONST objv[];
  2566         -    char * message;
  2567         -{
  2568         -    (tclStubsPtr->tcl_WrongNumArgs)(interp, objc, objv, message);
  2569         -}
  2570         -
  2571         -/* Slot 265 */
  2572         -int
  2573         -Tcl_DumpActiveMemory(fileName)
  2574         -    char * fileName;
  2575         -{
  2576         -    return (tclStubsPtr->tcl_DumpActiveMemory)(fileName);
  2577         -}
  2578         -
  2579         -/* Slot 266 */
  2580         -void
  2581         -Tcl_ValidateAllMemory(file, line)
  2582         -    char * file;
  2583         -    int line;
  2584         -{
  2585         -    (tclStubsPtr->tcl_ValidateAllMemory)(file, line);
  2586         -}
  2587         -
  2588         -/* Slot 267 */
  2589         -void
  2590         -Tcl_AppendResultVA(interp, argList)
  2591         -    Tcl_Interp * interp;
  2592         -    va_list argList;
  2593         -{
  2594         -    (tclStubsPtr->tcl_AppendResultVA)(interp, argList);
  2595         -}
  2596         -
  2597         -/* Slot 268 */
  2598         -void
  2599         -Tcl_AppendStringsToObjVA(objPtr, argList)
  2600         -    Tcl_Obj * objPtr;
  2601         -    va_list argList;
  2602         -{
  2603         -    (tclStubsPtr->tcl_AppendStringsToObjVA)(objPtr, argList);
  2604         -}
  2605         -
  2606         -/* Slot 269 */
  2607         -char *
  2608         -Tcl_HashStats(tablePtr)
  2609         -    Tcl_HashTable * tablePtr;
  2610         -{
  2611         -    return (tclStubsPtr->tcl_HashStats)(tablePtr);
  2612         -}
  2613         -
  2614         -/* Slot 270 */
  2615         -char *
  2616         -Tcl_ParseVar(interp, str, termPtr)
  2617         -    Tcl_Interp * interp;
  2618         -    char * str;
  2619         -    char ** termPtr;
  2620         -{
  2621         -    return (tclStubsPtr->tcl_ParseVar)(interp, str, termPtr);
  2622         -}
  2623         -
  2624         -/* Slot 271 */
  2625         -char *
  2626         -Tcl_PkgPresent(interp, name, version, exact)
  2627         -    Tcl_Interp * interp;
  2628         -    char * name;
  2629         -    char * version;
  2630         -    int exact;
  2631         -{
  2632         -    return (tclStubsPtr->tcl_PkgPresent)(interp, name, version, exact);
  2633         -}
  2634         -
  2635         -/* Slot 272 */
  2636         -char *
  2637         -Tcl_PkgPresentEx(interp, name, version, exact, clientDataPtr)
  2638         -    Tcl_Interp * interp;
  2639         -    char * name;
  2640         -    char * version;
  2641         -    int exact;
  2642         -    ClientData * clientDataPtr;
  2643         -{
  2644         -    return (tclStubsPtr->tcl_PkgPresentEx)(interp, name, version, exact, clientDataPtr);
  2645         -}
  2646         -
  2647         -/* Slot 273 */
  2648         -int
  2649         -Tcl_PkgProvide(interp, name, version)
  2650         -    Tcl_Interp * interp;
  2651         -    char * name;
  2652         -    char * version;
  2653         -{
  2654         -    return (tclStubsPtr->tcl_PkgProvide)(interp, name, version);
  2655         -}
  2656         -
  2657         -/* Slot 274 */
  2658         -char *
  2659         -Tcl_PkgRequire(interp, name, version, exact)
  2660         -    Tcl_Interp * interp;
  2661         -    char * name;
  2662         -    char * version;
  2663         -    int exact;
  2664         -{
  2665         -    return (tclStubsPtr->tcl_PkgRequire)(interp, name, version, exact);
  2666         -}
  2667         -
  2668         -/* Slot 275 */
  2669         -void
  2670         -Tcl_SetErrorCodeVA(interp, argList)
  2671         -    Tcl_Interp * interp;
  2672         -    va_list argList;
  2673         -{
  2674         -    (tclStubsPtr->tcl_SetErrorCodeVA)(interp, argList);
  2675         -}
  2676         -
  2677         -/* Slot 276 */
  2678         -int
  2679         -Tcl_VarEvalVA(interp, argList)
  2680         -    Tcl_Interp * interp;
  2681         -    va_list argList;
  2682         -{
  2683         -    return (tclStubsPtr->tcl_VarEvalVA)(interp, argList);
  2684         -}
  2685         -
  2686         -/* Slot 277 */
  2687         -Tcl_Pid
  2688         -Tcl_WaitPid(pid, statPtr, options)
  2689         -    Tcl_Pid pid;
  2690         -    int * statPtr;
  2691         -    int options;
  2692         -{
  2693         -    return (tclStubsPtr->tcl_WaitPid)(pid, statPtr, options);
  2694         -}
  2695         -
  2696         -/* Slot 278 */
  2697         -void
  2698         -Tcl_PanicVA(format, argList)
  2699         -    char * format;
  2700         -    va_list argList;
  2701         -{
  2702         -    (tclStubsPtr->tcl_PanicVA)(format, argList);
  2703         -}
  2704         -
  2705         -/* Slot 279 */
  2706         -void
  2707         -Tcl_GetVersion(major, minor, patchLevel, type)
  2708         -    int * major;
  2709         -    int * minor;
  2710         -    int * patchLevel;
  2711         -    int * type;
  2712         -{
  2713         -    (tclStubsPtr->tcl_GetVersion)(major, minor, patchLevel, type);
  2714         -}
  2715         -
  2716         -/* Slot 280 is reserved */
  2717         -/* Slot 281 is reserved */
  2718         -/* Slot 282 is reserved */
  2719         -/* Slot 283 is reserved */
  2720         -/* Slot 284 is reserved */
  2721         -/* Slot 285 is reserved */
  2722         -/* Slot 286 */
  2723         -void
  2724         -Tcl_AppendObjToObj(objPtr, appendObjPtr)
  2725         -    Tcl_Obj * objPtr;
  2726         -    Tcl_Obj * appendObjPtr;
  2727         -{
  2728         -    (tclStubsPtr->tcl_AppendObjToObj)(objPtr, appendObjPtr);
  2729         -}
  2730         -
  2731         -/* Slot 287 */
  2732         -Tcl_Encoding
  2733         -Tcl_CreateEncoding(typePtr)
  2734         -    Tcl_EncodingType * typePtr;
  2735         -{
  2736         -    return (tclStubsPtr->tcl_CreateEncoding)(typePtr);
  2737         -}
  2738         -
  2739         -/* Slot 288 */
  2740         -void
  2741         -Tcl_CreateThreadExitHandler(proc, clientData)
  2742         -    Tcl_ExitProc * proc;
  2743         -    ClientData clientData;
  2744         -{
  2745         -    (tclStubsPtr->tcl_CreateThreadExitHandler)(proc, clientData);
  2746         -}
  2747         -
  2748         -/* Slot 289 */
  2749         -void
  2750         -Tcl_DeleteThreadExitHandler(proc, clientData)
  2751         -    Tcl_ExitProc * proc;
  2752         -    ClientData clientData;
  2753         -{
  2754         -    (tclStubsPtr->tcl_DeleteThreadExitHandler)(proc, clientData);
  2755         -}
  2756         -
  2757         -/* Slot 290 */
  2758         -void
  2759         -Tcl_DiscardResult(statePtr)
  2760         -    Tcl_SavedResult * statePtr;
  2761         -{
  2762         -    (tclStubsPtr->tcl_DiscardResult)(statePtr);
  2763         -}
  2764         -
  2765         -/* Slot 291 */
  2766         -int
  2767         -Tcl_EvalEx(interp, script, numBytes, flags)
  2768         -    Tcl_Interp * interp;
  2769         -    char * script;
  2770         -    int numBytes;
  2771         -    int flags;
  2772         -{
  2773         -    return (tclStubsPtr->tcl_EvalEx)(interp, script, numBytes, flags);
  2774         -}
  2775         -
  2776         -/* Slot 292 */
  2777         -int
  2778         -Tcl_EvalObjv(interp, objc, objv, flags)
  2779         -    Tcl_Interp * interp;
  2780         -    int objc;
  2781         -    Tcl_Obj *CONST objv[];
  2782         -    int flags;
  2783         -{
  2784         -    return (tclStubsPtr->tcl_EvalObjv)(interp, objc, objv, flags);
  2785         -}
  2786         -
  2787         -/* Slot 293 */
  2788         -int
  2789         -Tcl_EvalObjEx(interp, objPtr, flags)
  2790         -    Tcl_Interp * interp;
  2791         -    Tcl_Obj * objPtr;
  2792         -    int flags;
  2793         -{
  2794         -    return (tclStubsPtr->tcl_EvalObjEx)(interp, objPtr, flags);
  2795         -}
  2796         -
  2797         -/* Slot 294 */
  2798         -void
  2799         -Tcl_ExitThread(status)
  2800         -    int status;
  2801         -{
  2802         -    (tclStubsPtr->tcl_ExitThread)(status);
  2803         -}
  2804         -
  2805         -/* Slot 295 */
  2806         -int
  2807         -Tcl_ExternalToUtf(interp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr)
  2808         -    Tcl_Interp * interp;
  2809         -    Tcl_Encoding encoding;
  2810         -    CONST char * src;
  2811         -    int srcLen;
  2812         -    int flags;
  2813         -    Tcl_EncodingState * statePtr;
  2814         -    char * dst;
  2815         -    int dstLen;
  2816         -    int * srcReadPtr;
  2817         -    int * dstWrotePtr;
  2818         -    int * dstCharsPtr;
  2819         -{
  2820         -    return (tclStubsPtr->tcl_ExternalToUtf)(interp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr);
  2821         -}
  2822         -
  2823         -/* Slot 296 */
  2824         -char *
  2825         -Tcl_ExternalToUtfDString(encoding, src, srcLen, dsPtr)
  2826         -    Tcl_Encoding encoding;
  2827         -    CONST char * src;
  2828         -    int srcLen;
  2829         -    Tcl_DString * dsPtr;
  2830         -{
  2831         -    return (tclStubsPtr->tcl_ExternalToUtfDString)(encoding, src, srcLen, dsPtr);
  2832         -}
  2833         -
  2834         -/* Slot 297 */
  2835         -void
  2836         -Tcl_FinalizeThread()
  2837         -{
  2838         -    (tclStubsPtr->tcl_FinalizeThread)();
  2839         -}
  2840         -
  2841         -/* Slot 298 */
  2842         -void
  2843         -Tcl_FinalizeNotifier(clientData)
  2844         -    ClientData clientData;
  2845         -{
  2846         -    (tclStubsPtr->tcl_FinalizeNotifier)(clientData);
  2847         -}
  2848         -
  2849         -/* Slot 299 */
  2850         -void
  2851         -Tcl_FreeEncoding(encoding)
  2852         -    Tcl_Encoding encoding;
  2853         -{
  2854         -    (tclStubsPtr->tcl_FreeEncoding)(encoding);
  2855         -}
  2856         -
  2857         -/* Slot 300 */
  2858         -Tcl_ThreadId
  2859         -Tcl_GetCurrentThread()
  2860         -{
  2861         -    return (tclStubsPtr->tcl_GetCurrentThread)();
  2862         -}
  2863         -
  2864         -/* Slot 301 */
  2865         -Tcl_Encoding
  2866         -Tcl_GetEncoding(interp, name)
  2867         -    Tcl_Interp * interp;
  2868         -    CONST char * name;
  2869         -{
  2870         -    return (tclStubsPtr->tcl_GetEncoding)(interp, name);
  2871         -}
  2872         -
  2873         -/* Slot 302 */
  2874         -char *
  2875         -Tcl_GetEncodingName(encoding)
  2876         -    Tcl_Encoding encoding;
  2877         -{
  2878         -    return (tclStubsPtr->tcl_GetEncodingName)(encoding);
  2879         -}
  2880         -
  2881         -/* Slot 303 */
  2882         -void
  2883         -Tcl_GetEncodingNames(interp)
  2884         -    Tcl_Interp * interp;
  2885         -{
  2886         -    (tclStubsPtr->tcl_GetEncodingNames)(interp);
  2887         -}
  2888         -
  2889         -/* Slot 304 */
  2890         -int
  2891         -Tcl_GetIndexFromObjStruct(interp, objPtr, tablePtr, offset, msg, flags, indexPtr)
  2892         -    Tcl_Interp * interp;
  2893         -    Tcl_Obj * objPtr;
  2894         -    char ** tablePtr;
  2895         -    int offset;
  2896         -    char * msg;
  2897         -    int flags;
  2898         -    int * indexPtr;
  2899         -{
  2900         -    return (tclStubsPtr->tcl_GetIndexFromObjStruct)(interp, objPtr, tablePtr, offset, msg, flags, indexPtr);
  2901         -}
  2902         -
  2903         -/* Slot 305 */
  2904         -VOID *
  2905         -Tcl_GetThreadData(keyPtr, size)
  2906         -    Tcl_ThreadDataKey * keyPtr;
  2907         -    int size;
  2908         -{
  2909         -    return (tclStubsPtr->tcl_GetThreadData)(keyPtr, size);
  2910         -}
  2911         -
  2912         -/* Slot 306 */
  2913         -Tcl_Obj *
  2914         -Tcl_GetVar2Ex(interp, part1, part2, flags)
  2915         -    Tcl_Interp * interp;
  2916         -    char * part1;
  2917         -    char * part2;
  2918         -    int flags;
  2919         -{
  2920         -    return (tclStubsPtr->tcl_GetVar2Ex)(interp, part1, part2, flags);
  2921         -}
  2922         -
  2923         -/* Slot 307 */
  2924         -ClientData
  2925         -Tcl_InitNotifier()
  2926         -{
  2927         -    return (tclStubsPtr->tcl_InitNotifier)();
  2928         -}
  2929         -
  2930         -/* Slot 308 */
  2931         -void
  2932         -Tcl_MutexLock(mutexPtr)
  2933         -    Tcl_Mutex * mutexPtr;
  2934         -{
  2935         -    (tclStubsPtr->tcl_MutexLock)(mutexPtr);
  2936         -}
  2937         -
  2938         -/* Slot 309 */
  2939         -void
  2940         -Tcl_MutexUnlock(mutexPtr)
  2941         -    Tcl_Mutex * mutexPtr;
  2942         -{
  2943         -    (tclStubsPtr->tcl_MutexUnlock)(mutexPtr);
  2944         -}
  2945         -
  2946         -/* Slot 310 */
  2947         -void
  2948         -Tcl_ConditionNotify(condPtr)
  2949         -    Tcl_Condition * condPtr;
  2950         -{
  2951         -    (tclStubsPtr->tcl_ConditionNotify)(condPtr);
  2952         -}
  2953         -
  2954         -/* Slot 311 */
  2955         -void
  2956         -Tcl_ConditionWait(condPtr, mutexPtr, timePtr)
  2957         -    Tcl_Condition * condPtr;
  2958         -    Tcl_Mutex * mutexPtr;
  2959         -    Tcl_Time * timePtr;
  2960         -{
  2961         -    (tclStubsPtr->tcl_ConditionWait)(condPtr, mutexPtr, timePtr);
  2962         -}
  2963         -
  2964         -/* Slot 312 */
  2965         -int
  2966         -Tcl_NumUtfChars(src, len)
  2967         -    CONST char * src;
  2968         -    int len;
  2969         -{
  2970         -    return (tclStubsPtr->tcl_NumUtfChars)(src, len);
  2971         -}
  2972         -
  2973         -/* Slot 313 */
  2974         -int
  2975         -Tcl_ReadChars(channel, objPtr, charsToRead, appendFlag)
  2976         -    Tcl_Channel channel;
  2977         -    Tcl_Obj * objPtr;
  2978         -    int charsToRead;
  2979         -    int appendFlag;
  2980         -{
  2981         -    return (tclStubsPtr->tcl_ReadChars)(channel, objPtr, charsToRead, appendFlag);
  2982         -}
  2983         -
  2984         -/* Slot 314 */
  2985         -void
  2986         -Tcl_RestoreResult(interp, statePtr)
  2987         -    Tcl_Interp * interp;
  2988         -    Tcl_SavedResult * statePtr;
  2989         -{
  2990         -    (tclStubsPtr->tcl_RestoreResult)(interp, statePtr);
  2991         -}
  2992         -
  2993         -/* Slot 315 */
  2994         -void
  2995         -Tcl_SaveResult(interp, statePtr)
  2996         -    Tcl_Interp * interp;
  2997         -    Tcl_SavedResult * statePtr;
  2998         -{
  2999         -    (tclStubsPtr->tcl_SaveResult)(interp, statePtr);
  3000         -}
  3001         -
  3002         -/* Slot 316 */
  3003         -int
  3004         -Tcl_SetSystemEncoding(interp, name)
  3005         -    Tcl_Interp * interp;
  3006         -    CONST char * name;
  3007         -{
  3008         -    return (tclStubsPtr->tcl_SetSystemEncoding)(interp, name);
  3009         -}
  3010         -
  3011         -/* Slot 317 */
  3012         -Tcl_Obj *
  3013         -Tcl_SetVar2Ex(interp, part1, part2, newValuePtr, flags)
  3014         -    Tcl_Interp * interp;
  3015         -    char * part1;
  3016         -    char * part2;
  3017         -    Tcl_Obj * newValuePtr;
  3018         -    int flags;
  3019         -{
  3020         -    return (tclStubsPtr->tcl_SetVar2Ex)(interp, part1, part2, newValuePtr, flags);
  3021         -}
  3022         -
  3023         -/* Slot 318 */
  3024         -void
  3025         -Tcl_ThreadAlert(threadId)
  3026         -    Tcl_ThreadId threadId;
  3027         -{
  3028         -    (tclStubsPtr->tcl_ThreadAlert)(threadId);
  3029         -}
  3030         -
  3031         -/* Slot 319 */
  3032         -void
  3033         -Tcl_ThreadQueueEvent(threadId, evPtr, position)
  3034         -    Tcl_ThreadId threadId;
  3035         -    Tcl_Event* evPtr;
  3036         -    Tcl_QueuePosition position;
  3037         -{
  3038         -    (tclStubsPtr->tcl_ThreadQueueEvent)(threadId, evPtr, position);
  3039         -}
  3040         -
  3041         -/* Slot 320 */
  3042         -Tcl_UniChar
  3043         -Tcl_UniCharAtIndex(src, index)
  3044         -    CONST char * src;
  3045         -    int index;
  3046         -{
  3047         -    return (tclStubsPtr->tcl_UniCharAtIndex)(src, index);
  3048         -}
  3049         -
  3050         -/* Slot 321 */
  3051         -Tcl_UniChar
  3052         -Tcl_UniCharToLower(ch)
  3053         -    int ch;
  3054         -{
  3055         -    return (tclStubsPtr->tcl_UniCharToLower)(ch);
  3056         -}
  3057         -
  3058         -/* Slot 322 */
  3059         -Tcl_UniChar
  3060         -Tcl_UniCharToTitle(ch)
  3061         -    int ch;
  3062         -{
  3063         -    return (tclStubsPtr->tcl_UniCharToTitle)(ch);
  3064         -}
  3065         -
  3066         -/* Slot 323 */
  3067         -Tcl_UniChar
  3068         -Tcl_UniCharToUpper(ch)
  3069         -    int ch;
  3070         -{
  3071         -    return (tclStubsPtr->tcl_UniCharToUpper)(ch);
  3072         -}
  3073         -
  3074         -/* Slot 324 */
  3075         -int
  3076         -Tcl_UniCharToUtf(ch, buf)
  3077         -    int ch;
  3078         -    char * buf;
  3079         -{
  3080         -    return (tclStubsPtr->tcl_UniCharToUtf)(ch, buf);
  3081         -}
  3082         -
  3083         -/* Slot 325 */
  3084         -char *
  3085         -Tcl_UtfAtIndex(src, index)
  3086         -    CONST char * src;
  3087         -    int index;
  3088         -{
  3089         -    return (tclStubsPtr->tcl_UtfAtIndex)(src, index);
  3090         -}
  3091         -
  3092         -/* Slot 326 */
  3093         -int
  3094         -Tcl_UtfCharComplete(src, len)
  3095         -    CONST char * src;
  3096         -    int len;
  3097         -{
  3098         -    return (tclStubsPtr->tcl_UtfCharComplete)(src, len);
  3099         -}
  3100         -
  3101         -/* Slot 327 */
  3102         -int
  3103         -Tcl_UtfBackslash(src, readPtr, dst)
  3104         -    CONST char * src;
  3105         -    int * readPtr;
  3106         -    char * dst;
  3107         -{
  3108         -    return (tclStubsPtr->tcl_UtfBackslash)(src, readPtr, dst);
  3109         -}
  3110         -
  3111         -/* Slot 328 */
  3112         -char *
  3113         -Tcl_UtfFindFirst(src, ch)
  3114         -    CONST char * src;
  3115         -    int ch;
  3116         -{
  3117         -    return (tclStubsPtr->tcl_UtfFindFirst)(src, ch);
  3118         -}
  3119         -
  3120         -/* Slot 329 */
  3121         -char *
  3122         -Tcl_UtfFindLast(src, ch)
  3123         -    CONST char * src;
  3124         -    int ch;
  3125         -{
  3126         -    return (tclStubsPtr->tcl_UtfFindLast)(src, ch);
  3127         -}
  3128         -
  3129         -/* Slot 330 */
  3130         -char *
  3131         -Tcl_UtfNext(src)
  3132         -    CONST char * src;
  3133         -{
  3134         -    return (tclStubsPtr->tcl_UtfNext)(src);
  3135         -}
  3136         -
  3137         -/* Slot 331 */
  3138         -char *
  3139         -Tcl_UtfPrev(src, start)
  3140         -    CONST char * src;
  3141         -    CONST char * start;
  3142         -{
  3143         -    return (tclStubsPtr->tcl_UtfPrev)(src, start);
  3144         -}
  3145         -
  3146         -/* Slot 332 */
  3147         -int
  3148         -Tcl_UtfToExternal(interp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr)
  3149         -    Tcl_Interp * interp;
  3150         -    Tcl_Encoding encoding;
  3151         -    CONST char * src;
  3152         -    int srcLen;
  3153         -    int flags;
  3154         -    Tcl_EncodingState * statePtr;
  3155         -    char * dst;
  3156         -    int dstLen;
  3157         -    int * srcReadPtr;
  3158         -    int * dstWrotePtr;
  3159         -    int * dstCharsPtr;
  3160         -{
  3161         -    return (tclStubsPtr->tcl_UtfToExternal)(interp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr);
  3162         -}
  3163         -
  3164         -/* Slot 333 */
  3165         -char *
  3166         -Tcl_UtfToExternalDString(encoding, src, srcLen, dsPtr)
  3167         -    Tcl_Encoding encoding;
  3168         -    CONST char * src;
  3169         -    int srcLen;
  3170         -    Tcl_DString * dsPtr;
  3171         -{
  3172         -    return (tclStubsPtr->tcl_UtfToExternalDString)(encoding, src, srcLen, dsPtr);
  3173         -}
  3174         -
  3175         -/* Slot 334 */
  3176         -int
  3177         -Tcl_UtfToLower(src)
  3178         -    char * src;
  3179         -{
  3180         -    return (tclStubsPtr->tcl_UtfToLower)(src);
  3181         -}
  3182         -
  3183         -/* Slot 335 */
  3184         -int
  3185         -Tcl_UtfToTitle(src)
  3186         -    char * src;
  3187         -{
  3188         -    return (tclStubsPtr->tcl_UtfToTitle)(src);
  3189         -}
  3190         -
  3191         -/* Slot 336 */
  3192         -int
  3193         -Tcl_UtfToUniChar(src, chPtr)
  3194         -    CONST char * src;
  3195         -    Tcl_UniChar * chPtr;
  3196         -{
  3197         -    return (tclStubsPtr->tcl_UtfToUniChar)(src, chPtr);
  3198         -}
  3199         -
  3200         -/* Slot 337 */
  3201         -int
  3202         -Tcl_UtfToUpper(src)
  3203         -    char * src;
  3204         -{
  3205         -    return (tclStubsPtr->tcl_UtfToUpper)(src);
  3206         -}
  3207         -
  3208         -/* Slot 338 */
  3209         -int
  3210         -Tcl_WriteChars(chan, src, srcLen)
  3211         -    Tcl_Channel chan;
  3212         -    CONST char * src;
  3213         -    int srcLen;
  3214         -{
  3215         -    return (tclStubsPtr->tcl_WriteChars)(chan, src, srcLen);
  3216         -}
  3217         -
  3218         -/* Slot 339 */
  3219         -int
  3220         -Tcl_WriteObj(chan, objPtr)
  3221         -    Tcl_Channel chan;
  3222         -    Tcl_Obj * objPtr;
  3223         -{
  3224         -    return (tclStubsPtr->tcl_WriteObj)(chan, objPtr);
  3225         -}
  3226         -
  3227         -/* Slot 340 */
  3228         -char *
  3229         -Tcl_GetString(objPtr)
  3230         -    Tcl_Obj * objPtr;
  3231         -{
  3232         -    return (tclStubsPtr->tcl_GetString)(objPtr);
  3233         -}
  3234         -
  3235         -/* Slot 341 */
  3236         -char *
  3237         -Tcl_GetDefaultEncodingDir()
  3238         -{
  3239         -    return (tclStubsPtr->tcl_GetDefaultEncodingDir)();
  3240         -}
  3241         -
  3242         -/* Slot 342 */
  3243         -void
  3244         -Tcl_SetDefaultEncodingDir(path)
  3245         -    char * path;
  3246         -{
  3247         -    (tclStubsPtr->tcl_SetDefaultEncodingDir)(path);
  3248         -}
  3249         -
  3250         -/* Slot 343 */
  3251         -void
  3252         -Tcl_AlertNotifier(clientData)
  3253         -    ClientData clientData;
  3254         -{
  3255         -    (tclStubsPtr->tcl_AlertNotifier)(clientData);
  3256         -}
  3257         -
  3258         -/* Slot 344 */
  3259         -void
  3260         -Tcl_ServiceModeHook(mode)
  3261         -    int mode;
  3262         -{
  3263         -    (tclStubsPtr->tcl_ServiceModeHook)(mode);
  3264         -}
  3265         -
  3266         -
  3267         -/* !END!: Do not edit above this line. */

Changes to tools/genStubs.tcl.

     4      4   #	interface.  
     5      5   #	
     6      6   #
     7      7   # Copyright (c) 1998-1999 by Scriptics Corporation.
     8      8   # See the file "license.terms" for information on usage and redistribution
     9      9   # of this file, and for a DISCLAIMER OF ALL WARRANTIES.
    10     10   # 
    11         -# RCS: @(#) $Id: genStubs.tcl,v 1.2.2.2 1999/03/25 23:29:19 stanton Exp $
           11  +# RCS: @(#) $Id: genStubs.tcl,v 1.2.2.3 1999/03/30 01:55:55 redman Exp $
    12     12   
    13     13   namespace eval genStubs {
    14     14       # libraryName --
    15     15       #
    16     16       #	The name of the entire library.  This value is used to compute
    17     17       #	the USE_*_STUB_PROCS macro and the name of the init file.
    18     18   
................................................................................
   417    417   	    foreach arg $args {
   418    418   		append argList $sep [lindex $arg 1]
   419    419   		set sep ", "
   420    420   	    }
   421    421   	    append argList ")"
   422    422   	}
   423    423       }
   424         -    append text $argList " \\\n\t(${name}StubsPtr->$lfname)$argList"
          424  +    append text " \\\n\t(${name}StubsPtr->$lfname)"
   425    425       append text " /* $index */\n#endif\n"
   426    426       return $text
   427    427   }
   428    428   
   429    429   # genStubs::makeStub --
   430    430   #
   431    431   #	Emits a stub function definition.
................................................................................
   846    846       foreach file [lrange $argv 1 end] {
   847    847   	source $file
   848    848       }
   849    849   
   850    850       foreach name [lsort [array names interfaces]] {
   851    851   	puts "Emitting $name"
   852    852   	emitHeader $name
   853         -	emitStubs $name
   854    853       }
   855    854   
   856    855       emitInits
   857    856   }
   858    857   
   859    858   # lassign --
   860    859   #

Changes to unix/Makefile.in.

     1      1   #
     2      2   # This file is a Makefile for Tcl.  If it has the name "Makefile.in"
     3      3   # then it is a template for a Makefile;  to generate the actual Makefile,
     4      4   # run "./configure", which is a configuration script generated by the
     5      5   # "autoconf" program (constructs like "@[email protected]" will get replaced in the
     6      6   # actual Makefile.
     7      7   #
     8         -# RCS: @(#) $Id: Makefile.in,v 1.1.2.21 1999/03/25 19:46:23 stanton Exp $
            8  +# RCS: @(#) $Id: Makefile.in,v 1.1.2.22 1999/03/30 01:55:56 redman Exp $
     9      9   
    10     10   # Current Tcl version;  used in various names.
    11     11   
    12     12   VERSION = @[email protected]
    13     13   
    14     14   #----------------------------------------------------------------
    15     15   # Things you can change to personalize the Makefile for your own
................................................................................
   268    268   	tclIOCmd.o tclIOSock.o tclIOUtil.o tclLink.o tclListObj.o \
   269    269   	tclLiteral.o tclLoad.o tclMain.o tclNamesp.o tclNotify.o \
   270    270   	tclObj.o tclPanic.o tclParse.o tclParseExpr.o tclPipe.o \
   271    271   	tclPkg.o tclPosixStr.o tclPreserve.o tclProc.o tclRegexp.o \
   272    272   	tclResolve.o tclResult.o tclScan.o tclStringObj.o tclThread.o \
   273    273   	tclStubInit.o tclTimer.o tclUtf.o tclUtil.o tclVar.o
   274    274   
   275         -STUB_LIB_OBJS = tclIntPlatStubs.o tclIntStubs.o tclPlatStubs.o tclStubLib.o \
   276         -	tclStubs.o ${COMPAT_OBJS}
          275  +STUB_LIB_OBJS = tclStubLib.o ${COMPAT_OBJS}
   277    276   
   278    277   OBJS = ${GENERIC_OBJS} ${UNIX_OBJS} ${NOTIFY_OBJS} ${COMPAT_OBJS} @[email protected]
   279    278   
   280    279   TCL_DECLS = \
   281    280   	$(GENERIC_DIR)/tcl.decls \
   282    281   	$(GENERIC_DIR)/tclInt.decls
   283    282   
................................................................................
   351    350   	$(GENERIC_DIR)/tclTestProcBodyObj.c \
   352    351   	$(GENERIC_DIR)/tclThread.c \
   353    352   	$(GENERIC_DIR)/tclTimer.c \
   354    353   	$(GENERIC_DIR)/tclUtil.c \
   355    354   	$(GENERIC_DIR)/tclVar.c
   356    355   
   357    356   STUB_SRCS = \
   358         -	$(GENERIC_DIR)/tclIntPlatStubs.c \
   359         -	$(GENERIC_DIR)/tclIntStubs.c \
   360         -	$(GENERIC_DIR)/tclPlatStubs.c \
   361    357   	$(GENERIC_DIR)/tclStubLib.c \
   362         -	$(GENERIC_DIR)/tclStubs.c
          358  +
   363    359   
   364    360   UNIX_HDRS = \
   365    361   	$(UNIX_DIR)/tclUnixPort.h
   366    362   
   367    363   UNIX_SRCS = \
   368    364   	$(UNIX_DIR)/tclAppInit.c \
   369    365   	$(UNIX_DIR)/tclMtherr.c \
................................................................................
   964    960   
   965    961   waitpid.o: $(COMPAT_DIR)/waitpid.c
   966    962   	$(CC) -c $(STUB_CC_SWITCHES) $(COMPAT_DIR)/waitpid.c
   967    963   
   968    964   # Stub library binaries, these must be compiled for use in a shared library
   969    965   # even though they will be placed in a static archive
   970    966   
   971         -tclIntPlatStubs.o: $(GENERIC_DIR)/tclIntPlatStubs.c
   972         -	$(CC) -c $(STUB_CC_SWITCHES) $(GENERIC_DIR)/tclIntPlatStubs.c
   973         -
   974         -tclIntStubs.o: $(GENERIC_DIR)/tclIntStubs.c
   975         -	$(CC) -c $(STUB_CC_SWITCHES) $(GENERIC_DIR)/tclIntStubs.c
   976         -
   977         -tclPlatStubs.o: $(GENERIC_DIR)/tclPlatStubs.c
   978         -	$(CC) -c $(STUB_CC_SWITCHES) $(GENERIC_DIR)/tclPlatStubs.c
   979    967   
   980    968   tclStubLib.o: $(GENERIC_DIR)/tclStubLib.c
   981    969   	$(CC) -c $(STUB_CC_SWITCHES) $(GENERIC_DIR)/tclStubLib.c
   982    970   
   983         -tclStubs.o: $(GENERIC_DIR)/tclStubs.c
   984         -	$(CC) -c $(STUB_CC_SWITCHES) $(GENERIC_DIR)/tclStubs.c
   985         -
   986    971   .c.o:
   987    972   	$(CC) -c $(CC_SWITCHES) $<
   988    973   
   989    974   #
   990    975   # Target to regenerate header files and stub files from the *.decls tables.
   991    976   #
   992    977   

Changes to unix/tclUnixPort.h.

    15     15    *
    16     16    * Copyright (c) 1991-1994 The Regents of the University of California.
    17     17    * Copyright (c) 1994-1997 Sun Microsystems, Inc.
    18     18    *
    19     19    * See the file "license.terms" for information on usage and redistribution
    20     20    * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
    21     21    *
    22         - * RCS: @(#) $Id: tclUnixPort.h,v 1.1.2.6 1999/03/11 01:50:33 stanton Exp $
           22  + * RCS: @(#) $Id: tclUnixPort.h,v 1.1.2.7 1999/03/30 01:55:56 redman Exp $
    23     23    */
    24     24   
    25     25   #ifndef _TCLUNIXPORT
    26     26   #define _TCLUNIXPORT
    27     27   
    28     28   #ifndef _TCLINT
    29     29   #   include "tclInt.h"
................................................................................
   460    460   
   461    461   /*
   462    462    * The following macros and declaration wrap the C runtime library
   463    463    * functions.
   464    464    */
   465    465   
   466    466   #define TclpExit		exit
          467  +
          468  +#ifdef TclpStat
          469  +#undef TclpStat
          470  +#endif
   467    471   
   468    472   EXTERN int		TclpLstat _ANSI_ARGS_((CONST char *path, 
   469    473   			    struct stat *buf));
   470    474   EXTERN int		TclpStat _ANSI_ARGS_((CONST char *path, 
   471    475   			    struct stat *buf));
   472    476   
   473    477   /*