Symaptic: os/persistentdata/persistentstorage/sqlite3api/TEST/TCL/tcldistribution/generic/tcl.decls@260cb5ec6c19

     1 # tcl.decls --

2 #

     3 #	This file contains the declarations for all supported public

     4 #	functions that are exported by the Tcl library via the stubs table.

     5 #	This file is used to generate the tclDecls.h, tclPlatDecls.h,

     6 #	tclStub.c, and tclPlatStub.c files.

7 #

8 #

     9 # Copyright (c) 1998-1999 by Scriptics Corporation.

    10 # Copyright (c) 2001, 2002 by Kevin B. Kenny.  All rights reserved.

    11 # See the file "license.terms" for information on usage and redistribution

    12 # of this file, and for a DISCLAIMER OF ALL WARRANTIES.

    13 #

    14 # RCS: @(#) $Id: tcl.decls,v 1.94.2.4 2006/09/22 01:26:22 andreas_kupries Exp $

    16 library tcl

    18 # Define the tcl interface with several sub interfaces:

    19 #     tclPlat	 - platform specific public

    20 #     tclInt	 - generic private

    21 #     tclPlatInt - platform specific private

    23 interface tcl

    24 hooks {tclPlat tclInt tclIntPlat}

    26 # Declare each of the functions in the public Tcl interface.  Note that

    27 # the an index should never be reused for a different function in order

    28 # to preserve backwards compatibility.

    30 declare 0 generic {

    31     int Tcl_PkgProvideEx(Tcl_Interp* interp, CONST char* name,

    32 	    CONST char* version, ClientData clientData)

    33 }

    34 declare 1 generic {

    35     CONST84_RETURN char * Tcl_PkgRequireEx(Tcl_Interp *interp, CONST char *name,

    36 	    CONST char *version, int exact, ClientData *clientDataPtr)

    37 }

    38 declare 2 generic {

    39     void Tcl_Panic(CONST char *format, ...)

    40 }

    41 declare 3 generic {

    42     char * Tcl_Alloc(unsigned int size)

    43 }

    44 declare 4 generic {

    45     void Tcl_Free(char *ptr)

    46 }

    47 declare 5 generic {

    48     char * Tcl_Realloc(char *ptr, unsigned int size)

    49 }

    50 declare 6 generic {

    51     char * Tcl_DbCkalloc(unsigned int size, CONST char *file, int line)

    52 }

    53 declare 7 generic {

    54     int Tcl_DbCkfree(char *ptr, CONST char *file, int line)

    55 }

    56 declare 8 generic {

    57     char * Tcl_DbCkrealloc(char *ptr, unsigned int size,

    58 	    CONST char *file, int line)

    59 }

    61 # Tcl_CreateFileHandler and Tcl_DeleteFileHandler are only available on unix,

    62 # but they are part of the old generic interface, so we include them here for

    63 # compatibility reasons.

    65 declare 9 unix {

    66     void Tcl_CreateFileHandler(int fd, int mask, Tcl_FileProc *proc,

    67 	    ClientData clientData)

    68 }

    69 declare 10 unix {

    70     void Tcl_DeleteFileHandler(int fd)

    71 }

    73 declare 11 generic {

    74     void Tcl_SetTimer(Tcl_Time *timePtr)

    75 }

    76 declare 12 generic {

    77     void Tcl_Sleep(int ms)

    78 }

    79 declare 13 generic {

    80     int Tcl_WaitForEvent(Tcl_Time *timePtr)

    81 }

    82 declare 14 generic {

    83     int Tcl_AppendAllObjTypes(Tcl_Interp *interp, Tcl_Obj *objPtr)

    84 }

    85 declare 15 generic {

    86     void Tcl_AppendStringsToObj(Tcl_Obj *objPtr, ...)

    87 }

    88 declare 16 generic {

    89     void Tcl_AppendToObj(Tcl_Obj* objPtr, CONST char* bytes, int length)

    90 }

    91 declare 17 generic {

    92     Tcl_Obj * Tcl_ConcatObj(int objc, Tcl_Obj *CONST objv[])

    93 }

    94 declare 18 generic {

    95     int Tcl_ConvertToType(Tcl_Interp *interp, Tcl_Obj *objPtr,

    96 	    Tcl_ObjType *typePtr)

    97 }

    98 declare 19 generic {

    99     void Tcl_DbDecrRefCount(Tcl_Obj *objPtr, CONST char *file, int line)

   100 }

   101 declare 20 generic {

   102     void Tcl_DbIncrRefCount(Tcl_Obj *objPtr, CONST char *file, int line)

   103 }

   104 declare 21 generic {

   105     int Tcl_DbIsShared(Tcl_Obj *objPtr, CONST char *file, int line)

   106 }

   107 declare 22 generic {

   108     Tcl_Obj * Tcl_DbNewBooleanObj(int boolValue, CONST char *file, int line)

   109 }

   110 declare 23 generic {

   111     Tcl_Obj * Tcl_DbNewByteArrayObj(CONST unsigned char *bytes, int length,

   112 	    CONST char *file, int line)

   113 }

   114 declare 24 generic {

   115     Tcl_Obj * Tcl_DbNewDoubleObj(double doubleValue,

   116 	    CONST char *file, int line)

   117 }

   118 declare 25 generic {

   119     Tcl_Obj * Tcl_DbNewListObj(int objc, Tcl_Obj *CONST *objv,

   120 	    CONST char *file, int line)

   121 }

   122 declare 26 generic {

   123     Tcl_Obj * Tcl_DbNewLongObj(long longValue, CONST char *file, int line)

   124 }

   125 declare 27 generic {

   126     Tcl_Obj * Tcl_DbNewObj(CONST char *file, int line)

   127 }

   128 declare 28 generic {

   129     Tcl_Obj * Tcl_DbNewStringObj(CONST char *bytes, int length,

   130 	    CONST char *file, int line)

   131 }

   132 declare 29 generic {

   133     Tcl_Obj * Tcl_DuplicateObj(Tcl_Obj *objPtr)

   134 }

   135 declare 30 generic {

   136     void TclFreeObj(Tcl_Obj *objPtr)

   137 }

   138 declare 31 generic {

   139     int Tcl_GetBoolean(Tcl_Interp *interp, CONST char *str, int *boolPtr)

   140 }

   141 declare 32 generic {

   142     int Tcl_GetBooleanFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,

   143 	    int *boolPtr)

   144 }

   145 declare 33 generic {

   146     unsigned char * Tcl_GetByteArrayFromObj(Tcl_Obj *objPtr, int *lengthPtr)

   147 }

   148 declare 34 generic {

   149     int Tcl_GetDouble(Tcl_Interp *interp, CONST char *str, double *doublePtr)

   150 }

   151 declare 35 generic {

   152     int Tcl_GetDoubleFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,

   153 	    double *doublePtr)

   154 }

   155 declare 36 generic {

   156     int Tcl_GetIndexFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,

   157 	    CONST84 char **tablePtr, CONST char *msg, int flags, int *indexPtr)

   158 }

   159 declare 37 generic {

   160     int Tcl_GetInt(Tcl_Interp *interp, CONST char *str, int *intPtr)

   161 }

   162 declare 38 generic {

   163     int Tcl_GetIntFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *intPtr)

   164 }

   165 declare 39 generic {

   166     int Tcl_GetLongFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, long *longPtr)

   167 }

   168 declare 40 generic {

   169     Tcl_ObjType * Tcl_GetObjType(CONST char *typeName)

   170 }

   171 declare 41 generic {

   172     char * Tcl_GetStringFromObj(Tcl_Obj *objPtr, int *lengthPtr)

   173 }

   174 declare 42 generic {

   175     void Tcl_InvalidateStringRep(Tcl_Obj *objPtr)

   176 }

   177 declare 43 generic {

   178     int Tcl_ListObjAppendList(Tcl_Interp *interp, Tcl_Obj *listPtr,

   179 	    Tcl_Obj *elemListPtr)

   180 }

   181 declare 44 generic {

   182     int Tcl_ListObjAppendElement(Tcl_Interp *interp, Tcl_Obj *listPtr,

   183 	    Tcl_Obj *objPtr)

   184 }

   185 declare 45 generic {

   186     int Tcl_ListObjGetElements(Tcl_Interp *interp, Tcl_Obj *listPtr,

   187 	    int *objcPtr, Tcl_Obj ***objvPtr)

   188 }

   189 declare 46 generic {

   190     int Tcl_ListObjIndex(Tcl_Interp *interp, Tcl_Obj *listPtr, int index,

   191 	    Tcl_Obj **objPtrPtr)

   192 }

   193 declare 47 generic {

   194     int Tcl_ListObjLength(Tcl_Interp *interp, Tcl_Obj *listPtr,

   195 	    int *lengthPtr)

   196 }

   197 declare 48 generic {

   198     int Tcl_ListObjReplace(Tcl_Interp *interp, Tcl_Obj *listPtr, int first,

   199 	    int count, int objc, Tcl_Obj *CONST objv[])

   200 }

   201 declare 49 generic {

   202     Tcl_Obj *Tcl_NewBooleanObj(int boolValue)

   203 }

   204 declare 50 generic {

   205     Tcl_Obj *Tcl_NewByteArrayObj(CONST unsigned char* bytes, int length)

   206 }

   207 declare 51 generic {

   208     Tcl_Obj * Tcl_NewDoubleObj(double doubleValue)

   209 }

   210 declare 52 generic {

   211     Tcl_Obj * Tcl_NewIntObj(int intValue)

   212 }

   213 declare 53 generic {

   214     Tcl_Obj * Tcl_NewListObj(int objc, Tcl_Obj *CONST objv[])

   215 }

   216 declare 54 generic {

   217     Tcl_Obj * Tcl_NewLongObj(long longValue)

   218 }

   219 declare 55 generic {

   220     Tcl_Obj * Tcl_NewObj(void)

   221 }

   222 declare 56 generic {

   223     Tcl_Obj *Tcl_NewStringObj(CONST char *bytes, int length)

   224 }

   225 declare 57 generic {

   226     void Tcl_SetBooleanObj(Tcl_Obj *objPtr, int boolValue)

   227 }

   228 declare 58 generic {

   229     unsigned char * Tcl_SetByteArrayLength(Tcl_Obj *objPtr, int length)

   230 }

   231 declare 59 generic {

   232     void Tcl_SetByteArrayObj(Tcl_Obj *objPtr, CONST unsigned char *bytes,

   233 	    int length)

   234 }

   235 declare 60 generic {

   236     void Tcl_SetDoubleObj(Tcl_Obj *objPtr, double doubleValue)

   237 }

   238 declare 61 generic {

   239     void Tcl_SetIntObj(Tcl_Obj *objPtr, int intValue)

   240 }

   241 declare 62 generic {

   242     void Tcl_SetListObj(Tcl_Obj *objPtr, int objc, Tcl_Obj *CONST objv[])

   243 }

   244 declare 63 generic {

   245     void Tcl_SetLongObj(Tcl_Obj *objPtr, long longValue)

   246 }

   247 declare 64 generic {

   248     void Tcl_SetObjLength(Tcl_Obj *objPtr, int length)

   249 }

   250 declare 65 generic {

   251     void Tcl_SetStringObj(Tcl_Obj* objPtr, CONST char* bytes, int length)

   252 }

   253 declare 66 generic {

   254     void Tcl_AddErrorInfo(Tcl_Interp *interp, CONST char *message)

   255 }

   256 declare 67 generic {

   257     void Tcl_AddObjErrorInfo(Tcl_Interp *interp, CONST char *message,

   258 	    int length)

   259 }

   260 declare 68 generic {

   261     void Tcl_AllowExceptions(Tcl_Interp *interp)

   262 }

   263 declare 69 generic {

   264     void Tcl_AppendElement(Tcl_Interp *interp, CONST char *string)

   265 }

   266 declare 70 generic {

   267     void Tcl_AppendResult(Tcl_Interp *interp, ...)

   268 }

   269 declare 71 generic {

   270     Tcl_AsyncHandler Tcl_AsyncCreate(Tcl_AsyncProc *proc,

   271 	    ClientData clientData)

   272 }

   273 declare 72 generic {

   274     void Tcl_AsyncDelete(Tcl_AsyncHandler async)

   275 }

   276 declare 73 generic {

   277     int Tcl_AsyncInvoke(Tcl_Interp *interp, int code)

   278 }

   279 declare 74 generic {

   280     void Tcl_AsyncMark(Tcl_AsyncHandler async)

   281 }

   282 declare 75 generic {

   283     int Tcl_AsyncReady(void)

   284 }

   285 declare 76 generic {

   286     void Tcl_BackgroundError(Tcl_Interp *interp)

   287 }

   288 declare 77 generic {

   289     char Tcl_Backslash(CONST char *src, int *readPtr)

   290 }

   291 declare 78 generic {

   292     int Tcl_BadChannelOption(Tcl_Interp *interp, CONST char *optionName,

   293 	    CONST char *optionList)

   294 }

   295 declare 79 generic {

   296     void Tcl_CallWhenDeleted(Tcl_Interp *interp, Tcl_InterpDeleteProc *proc,

   297 	    ClientData clientData)

   298 }

   299 declare 80 generic {

   300     void Tcl_CancelIdleCall(Tcl_IdleProc *idleProc, ClientData clientData)

   301 }

   302 declare 81 generic {

   303     int Tcl_Close(Tcl_Interp *interp, Tcl_Channel chan)

   304 }

   305 declare 82 generic {

   306     int Tcl_CommandComplete(CONST char *cmd)

   307 }

   308 declare 83 generic {

   309     char * Tcl_Concat(int argc, CONST84 char * CONST *argv)

   310 }

   311 declare 84 generic {

   312     int Tcl_ConvertElement(CONST char *src, char *dst, int flags)

   313 }

   314 declare 85 generic {

   315     int Tcl_ConvertCountedElement(CONST char *src, int length, char *dst,

   316 	    int flags)

   317 }

   318 declare 86 generic {

   319     int Tcl_CreateAlias(Tcl_Interp *slave, CONST char *slaveCmd,

   320 	    Tcl_Interp *target, CONST char *targetCmd, int argc,

   321 	    CONST84 char * CONST *argv)

   322 }

   323 declare 87 generic {

   324     int Tcl_CreateAliasObj(Tcl_Interp *slave, CONST char *slaveCmd,

   325 	    Tcl_Interp *target, CONST char *targetCmd, int objc,

   326 	    Tcl_Obj *CONST objv[])

   327 }

   328 declare 88 generic {

   329     Tcl_Channel Tcl_CreateChannel(Tcl_ChannelType *typePtr,

   330 	    CONST char *chanName, ClientData instanceData, int mask)

   331 }

   332 declare 89 generic {

   333     void Tcl_CreateChannelHandler(Tcl_Channel chan, int mask,

   334 	    Tcl_ChannelProc *proc, ClientData clientData)

   335 }

   336 declare 90 generic {

   337     void Tcl_CreateCloseHandler(Tcl_Channel chan, Tcl_CloseProc *proc,

   338 	    ClientData clientData)

   339 }

   340 declare 91 generic {

   341     Tcl_Command Tcl_CreateCommand(Tcl_Interp *interp, CONST char *cmdName,

   342 	    Tcl_CmdProc *proc, ClientData clientData,

   343 	    Tcl_CmdDeleteProc *deleteProc)

   344 }

   345 declare 92 generic {

   346     void Tcl_CreateEventSource(Tcl_EventSetupProc *setupProc,

   347 	    Tcl_EventCheckProc *checkProc, ClientData clientData)

   348 }

   349 declare 93 generic {

   350     void Tcl_CreateExitHandler(Tcl_ExitProc *proc, ClientData clientData)

   351 }

   352 declare 94 generic {

   353     Tcl_Interp * Tcl_CreateInterp(void)

   354 }

   355 declare 95 generic {

   356     void Tcl_CreateMathFunc(Tcl_Interp *interp, CONST char *name,

   357 	    int numArgs, Tcl_ValueType *argTypes,

   358 	    Tcl_MathProc *proc, ClientData clientData)

   359 }

   360 declare 96 generic {

   361     Tcl_Command Tcl_CreateObjCommand(Tcl_Interp *interp,

   362 	    CONST char *cmdName,

   363 	    Tcl_ObjCmdProc *proc, ClientData clientData,

   364 	    Tcl_CmdDeleteProc *deleteProc)

   365 }

   366 declare 97 generic {

   367     Tcl_Interp * Tcl_CreateSlave(Tcl_Interp *interp, CONST char *slaveName,

   368 	    int isSafe)

   369 }

   370 declare 98 generic {

   371     Tcl_TimerToken Tcl_CreateTimerHandler(int milliseconds,

   372 	    Tcl_TimerProc *proc, ClientData clientData)

   373 }

   374 declare 99 generic {

   375     Tcl_Trace Tcl_CreateTrace(Tcl_Interp *interp, int level,

   376 	    Tcl_CmdTraceProc *proc, ClientData clientData)

   377 }

   378 declare 100 generic {

   379     void Tcl_DeleteAssocData(Tcl_Interp *interp, CONST char *name)

   380 }

   381 declare 101 generic {

   382     void Tcl_DeleteChannelHandler(Tcl_Channel chan, Tcl_ChannelProc *proc,

   383 	    ClientData clientData)

   384 }

   385 declare 102 generic {

   386     void Tcl_DeleteCloseHandler(Tcl_Channel chan, Tcl_CloseProc *proc,

   387 	    ClientData clientData)

   388 }

   389 declare 103 generic {

   390     int Tcl_DeleteCommand(Tcl_Interp *interp, CONST char *cmdName)

   391 }

   392 declare 104 generic {

   393     int Tcl_DeleteCommandFromToken(Tcl_Interp *interp, Tcl_Command command)

   394 }

   395 declare 105 generic {

   396     void Tcl_DeleteEvents(Tcl_EventDeleteProc *proc, ClientData clientData)

   397 }

   398 declare 106 generic {

   399     void Tcl_DeleteEventSource(Tcl_EventSetupProc *setupProc,

   400 	    Tcl_EventCheckProc *checkProc, ClientData clientData)

   401 }

   402 declare 107 generic {

   403     void Tcl_DeleteExitHandler(Tcl_ExitProc *proc, ClientData clientData)

   404 }

   405 declare 108 generic {

   406     void Tcl_DeleteHashEntry(Tcl_HashEntry *entryPtr)

   407 }

   408 declare 109 generic {

   409     void Tcl_DeleteHashTable(Tcl_HashTable *tablePtr)

   410 }

   411 declare 110 generic {

   412     void Tcl_DeleteInterp(Tcl_Interp *interp)

   413 }

   414 declare 111 {unix win} {

   415     void Tcl_DetachPids(int numPids, Tcl_Pid *pidPtr)

   416 }

   417 declare 112 generic {

   418     void Tcl_DeleteTimerHandler(Tcl_TimerToken token)

   419 }

   420 declare 113 generic {

   421     void Tcl_DeleteTrace(Tcl_Interp *interp, Tcl_Trace trace)

   422 }

   423 declare 114 generic {

   424     void Tcl_DontCallWhenDeleted(Tcl_Interp *interp,

   425 	    Tcl_InterpDeleteProc *proc, ClientData clientData)

   426 }

   427 declare 115 generic {

   428     int Tcl_DoOneEvent(int flags)

   429 }

   430 declare 116 generic {

   431     void Tcl_DoWhenIdle(Tcl_IdleProc *proc, ClientData clientData)

   432 }

   433 declare 117 generic {

   434     char * Tcl_DStringAppend(Tcl_DString *dsPtr, CONST char *str, int length)

   435 }

   436 declare 118 generic {

   437     char * Tcl_DStringAppendElement(Tcl_DString *dsPtr, CONST char *string)

   438 }

   439 declare 119 generic {

   440     void Tcl_DStringEndSublist(Tcl_DString *dsPtr)

   441 }

   442 declare 120 generic {

   443     void Tcl_DStringFree(Tcl_DString *dsPtr)

   444 }

   445 declare 121 generic {

   446     void Tcl_DStringGetResult(Tcl_Interp *interp, Tcl_DString *dsPtr)

   447 }

   448 declare 122 generic {

   449     void Tcl_DStringInit(Tcl_DString *dsPtr)

   450 }

   451 declare 123 generic {

   452     void Tcl_DStringResult(Tcl_Interp *interp, Tcl_DString *dsPtr)

   453 }

   454 declare 124 generic {

   455     void Tcl_DStringSetLength(Tcl_DString *dsPtr, int length)

   456 }

   457 declare 125 generic {

   458     void Tcl_DStringStartSublist(Tcl_DString *dsPtr)

   459 }

   460 declare 126 generic {

   461     int Tcl_Eof(Tcl_Channel chan)

   462 }

   463 declare 127 generic {

   464     CONST84_RETURN char * Tcl_ErrnoId(void)

   465 }

   466 declare 128 generic {

   467     CONST84_RETURN char * Tcl_ErrnoMsg(int err)

   468 }

   469 declare 129 generic {

   470     int Tcl_Eval(Tcl_Interp *interp, CONST char *string)

   471 }

   472 # This is obsolete, use Tcl_FSEvalFile

   473 declare 130 generic {

   474     int Tcl_EvalFile(Tcl_Interp *interp, CONST char *fileName)

   475 }

   476 declare 131 generic {

   477     int Tcl_EvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr)

   478 }

   479 declare 132 generic {

   480     void Tcl_EventuallyFree(ClientData clientData, Tcl_FreeProc *freeProc)

   481 }

   482 declare 133 generic {

   483     void Tcl_Exit(int status)

   484 }

   485 declare 134 generic {

   486     int Tcl_ExposeCommand(Tcl_Interp *interp, CONST char *hiddenCmdToken,

   487 	    CONST char *cmdName)

   488 }

   489 declare 135 generic {

   490     int Tcl_ExprBoolean(Tcl_Interp *interp, CONST char *str, int *ptr)

   491 }

   492 declare 136 generic {

   493     int Tcl_ExprBooleanObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *ptr)

   494 }

   495 declare 137 generic {

   496     int Tcl_ExprDouble(Tcl_Interp *interp, CONST char *str, double *ptr)

   497 }

   498 declare 138 generic {

   499     int Tcl_ExprDoubleObj(Tcl_Interp *interp, Tcl_Obj *objPtr, double *ptr)

   500 }

   501 declare 139 generic {

   502     int Tcl_ExprLong(Tcl_Interp *interp, CONST char *str, long *ptr)

   503 }

   504 declare 140 generic {

   505     int Tcl_ExprLongObj(Tcl_Interp *interp, Tcl_Obj *objPtr, long *ptr)

   506 }

   507 declare 141 generic {

   508     int Tcl_ExprObj(Tcl_Interp *interp, Tcl_Obj *objPtr,

   509 	    Tcl_Obj **resultPtrPtr)

   510 }

   511 declare 142 generic {

   512     int Tcl_ExprString(Tcl_Interp *interp, CONST char *string)

   513 }

   514 declare 143 generic {

   515     void Tcl_Finalize(void)

   516 }

   517 declare 144 generic {

   518     void Tcl_FindExecutable(CONST char *argv0)

   519 }

   520 declare 145 generic {

   521     Tcl_HashEntry * Tcl_FirstHashEntry(Tcl_HashTable *tablePtr,

   522 	    Tcl_HashSearch *searchPtr)

   523 }

   524 declare 146 generic {

   525     int Tcl_Flush(Tcl_Channel chan)

   526 }

   527 declare 147 generic {

   528     void Tcl_FreeResult(Tcl_Interp *interp)

   529 }

   530 declare 148 generic {

   531     int Tcl_GetAlias(Tcl_Interp *interp, CONST char *slaveCmd,

   532 	    Tcl_Interp **targetInterpPtr, CONST84 char **targetCmdPtr,

   533 	    int *argcPtr, CONST84 char ***argvPtr)

   534 }

   535 declare 149 generic {

   536     int Tcl_GetAliasObj(Tcl_Interp *interp, CONST char *slaveCmd,

   537 	    Tcl_Interp **targetInterpPtr, CONST84 char **targetCmdPtr,

   538 	    int *objcPtr, Tcl_Obj ***objv)

   539 }

   540 declare 150 generic {

   541     ClientData Tcl_GetAssocData(Tcl_Interp *interp, CONST char *name,

   542 	    Tcl_InterpDeleteProc **procPtr)

   543 }

   544 declare 151 generic {

   545     Tcl_Channel Tcl_GetChannel(Tcl_Interp *interp, CONST char *chanName,

   546 	    int *modePtr)

   547 }

   548 declare 152 generic {

   549     int Tcl_GetChannelBufferSize(Tcl_Channel chan)

   550 }

   551 declare 153 generic {

   552     int Tcl_GetChannelHandle(Tcl_Channel chan, int direction,

   553 	    ClientData *handlePtr)

   554 }

   555 declare 154 generic {

   556     ClientData Tcl_GetChannelInstanceData(Tcl_Channel chan)

   557 }

   558 declare 155 generic {

   559     int Tcl_GetChannelMode(Tcl_Channel chan)

   560 }

   561 declare 156 generic {

   562     CONST84_RETURN char * Tcl_GetChannelName(Tcl_Channel chan)

   563 }

   564 declare 157 generic {

   565     int Tcl_GetChannelOption(Tcl_Interp *interp, Tcl_Channel chan,

   566 	    CONST char *optionName, Tcl_DString *dsPtr)

   567 }

   568 declare 158 generic {

   569     Tcl_ChannelType * Tcl_GetChannelType(Tcl_Channel chan)

   570 }

   571 declare 159 generic {

   572     int Tcl_GetCommandInfo(Tcl_Interp *interp, CONST char *cmdName,

   573 	    Tcl_CmdInfo *infoPtr)

   574 }

   575 declare 160 generic {

   576     CONST84_RETURN char * Tcl_GetCommandName(Tcl_Interp *interp,

   577 	    Tcl_Command command)

   578 }

   579 declare 161 generic {

   580     int Tcl_GetErrno(void)

   581 }

   582 declare 162 generic {

   583     CONST84_RETURN char * Tcl_GetHostName(void)

   584 }

   585 declare 163 generic {

   586     int Tcl_GetInterpPath(Tcl_Interp *askInterp, Tcl_Interp *slaveInterp)

   587 }

   588 declare 164 generic {

   589     Tcl_Interp * Tcl_GetMaster(Tcl_Interp *interp)

   590 }

   591 declare 165 generic {

   592     CONST char * Tcl_GetNameOfExecutable(void)

   593 }

   594 declare 166 generic {

   595     Tcl_Obj * Tcl_GetObjResult(Tcl_Interp *interp)

   596 }

   598 # Tcl_GetOpenFile is only available on unix, but it is a part of the old

   599 # generic interface, so we inlcude it here for compatibility reasons.

   601 declare 167 unix {

   602     int Tcl_GetOpenFile(Tcl_Interp *interp, CONST char *str, int forWriting,

   603 	    int checkUsage, ClientData *filePtr)

   604 }

   605 # Obsolete.  Should now use Tcl_FSGetPathType which is objectified

   606 # and therefore usually faster.

   607 declare 168 generic {

   608     Tcl_PathType Tcl_GetPathType(CONST char *path)

   609 }

   610 declare 169 generic {

   611     int Tcl_Gets(Tcl_Channel chan, Tcl_DString *dsPtr)

   612 }

   613 declare 170 generic {

   614     int Tcl_GetsObj(Tcl_Channel chan, Tcl_Obj *objPtr)

   615 }

   616 declare 171 generic {

   617     int Tcl_GetServiceMode(void)

   618 }

   619 declare 172 generic {

   620     Tcl_Interp * Tcl_GetSlave(Tcl_Interp *interp, CONST char *slaveName)

   621 }

   622 declare 173 generic {

   623     Tcl_Channel Tcl_GetStdChannel(int type)

   624 }

   625 declare 174 generic {

   626     CONST84_RETURN char * Tcl_GetStringResult(Tcl_Interp *interp)

   627 }

   628 declare 175 generic {

   629     CONST84_RETURN char * Tcl_GetVar(Tcl_Interp *interp, CONST char *varName,

   630 	    int flags)

   631 }

   632 declare 176 generic {

   633     CONST84_RETURN char * Tcl_GetVar2(Tcl_Interp *interp, CONST char *part1,

   634 	    CONST char *part2, int flags)

   635 }

   636 declare 177 generic {

   637     int Tcl_GlobalEval(Tcl_Interp *interp, CONST char *command)

   638 }

   639 declare 178 generic {

   640     int Tcl_GlobalEvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr)

   641 }

   642 declare 179 generic {

   643     int Tcl_HideCommand(Tcl_Interp *interp, CONST char *cmdName,

   644 	    CONST char *hiddenCmdToken)

   645 }

   646 declare 180 generic {

   647     int Tcl_Init(Tcl_Interp *interp)

   648 }

   649 declare 181 generic {

   650     void Tcl_InitHashTable(Tcl_HashTable *tablePtr, int keyType)

   651 }

   652 declare 182 generic {

   653     int Tcl_InputBlocked(Tcl_Channel chan)

   654 }

   655 declare 183 generic {

   656     int Tcl_InputBuffered(Tcl_Channel chan)

   657 }

   658 declare 184 generic {

   659     int Tcl_InterpDeleted(Tcl_Interp *interp)

   660 }

   661 declare 185 generic {

   662     int Tcl_IsSafe(Tcl_Interp *interp)

   663 }

   664 # Obsolete, use Tcl_FSJoinPath

   665 declare 186 generic {

   666     char * Tcl_JoinPath(int argc, CONST84 char * CONST *argv,

   667 	    Tcl_DString *resultPtr)

   668 }

   669 declare 187 generic {

   670     int Tcl_LinkVar(Tcl_Interp *interp, CONST char *varName, char *addr,

   671 	    int type)

   672 }

   674 # This slot is reserved for use by the plus patch:

   675 #  declare 188 generic {

   676 #      Tcl_MainLoop

   677 #  }

   679 declare 189 generic {

   680     Tcl_Channel Tcl_MakeFileChannel(ClientData handle, int mode)

   681 }

   682 declare 190 generic {

   683     int Tcl_MakeSafe(Tcl_Interp *interp)

   684 }

   685 declare 191 generic {

   686     Tcl_Channel Tcl_MakeTcpClientChannel(ClientData tcpSocket)

   687 }

   688 declare 192 generic {

   689     char * Tcl_Merge(int argc, CONST84 char * CONST *argv)

   690 }

   691 declare 193 generic {

   692     Tcl_HashEntry * Tcl_NextHashEntry(Tcl_HashSearch *searchPtr)

   693 }

   694 declare 194 generic {

   695     void Tcl_NotifyChannel(Tcl_Channel channel, int mask)

   696 }

   697 declare 195 generic {

   698     Tcl_Obj * Tcl_ObjGetVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr,

   699 	    Tcl_Obj *part2Ptr, int flags)

   700 }

   701 declare 196 generic {

   702     Tcl_Obj * Tcl_ObjSetVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr,

   703 	    Tcl_Obj *part2Ptr, Tcl_Obj *newValuePtr, int flags)

   704 }

   705 declare 197 {unix win} {

   706     Tcl_Channel Tcl_OpenCommandChannel(Tcl_Interp *interp, int argc,

   707 	    CONST84 char **argv, int flags)

   708 }

   709 # This is obsolete, use Tcl_FSOpenFileChannel

   710 declare 198 generic {

   711     Tcl_Channel Tcl_OpenFileChannel(Tcl_Interp *interp, CONST char *fileName,

   712 	    CONST char *modeString, int permissions)

   713 }

   714 declare 199 generic {

   715     Tcl_Channel Tcl_OpenTcpClient(Tcl_Interp *interp, int port,

   716 	    CONST char *address, CONST char *myaddr, int myport, int async)

   717 }

   718 declare 200 generic {

   719     Tcl_Channel Tcl_OpenTcpServer(Tcl_Interp *interp, int port,

   720 	    CONST char *host, Tcl_TcpAcceptProc *acceptProc,

   721 	    ClientData callbackData)

   722 }

   723 declare 201 generic {

   724     void Tcl_Preserve(ClientData data)

   725 }

   726 declare 202 generic {

   727     void Tcl_PrintDouble(Tcl_Interp *interp, double value, char *dst)

   728 }

   729 declare 203 generic {

   730     int Tcl_PutEnv(CONST char *string)

   731 }

   732 declare 204 generic {

   733     CONST84_RETURN char * Tcl_PosixError(Tcl_Interp *interp)

   734 }

   735 declare 205 generic {

   736     void Tcl_QueueEvent(Tcl_Event *evPtr, Tcl_QueuePosition position)

   737 }

   738 declare 206 generic {

   739     int Tcl_Read(Tcl_Channel chan, char *bufPtr, int toRead)

   740 }

   741 declare 207 {unix win} {

   742     void Tcl_ReapDetachedProcs(void)

   743 }

   744 declare 208 generic {

   745     int Tcl_RecordAndEval(Tcl_Interp *interp, CONST char *cmd, int flags)

   746 }

   747 declare 209 generic {

   748     int Tcl_RecordAndEvalObj(Tcl_Interp *interp, Tcl_Obj *cmdPtr, int flags)

   749 }

   750 declare 210 generic {

   751     void Tcl_RegisterChannel(Tcl_Interp *interp, Tcl_Channel chan)

   752 }

   753 declare 211 generic {

   754     void Tcl_RegisterObjType(Tcl_ObjType *typePtr)

   755 }

   756 declare 212 generic {

   757     Tcl_RegExp Tcl_RegExpCompile(Tcl_Interp *interp, CONST char *string)

   758 }

   759 declare 213 generic {

   760     int Tcl_RegExpExec(Tcl_Interp *interp, Tcl_RegExp regexp,

   761 	    CONST char *str, CONST char *start)

   762 }

   763 declare 214 generic {

   764     int Tcl_RegExpMatch(Tcl_Interp *interp, CONST char *str,

   765 	    CONST char *pattern)

   766 }

   767 declare 215 generic {

   768     void Tcl_RegExpRange(Tcl_RegExp regexp, int index,

   769 	    CONST84 char **startPtr, CONST84 char **endPtr)

   770 }

   771 declare 216 generic {

   772     void Tcl_Release(ClientData clientData)

   773 }

   774 declare 217 generic {

   775     void Tcl_ResetResult(Tcl_Interp *interp)

   776 }

   777 declare 218 generic {

   778     int Tcl_ScanElement(CONST char *str, int *flagPtr)

   779 }

   780 declare 219 generic {

   781     int Tcl_ScanCountedElement(CONST char *str, int length, int *flagPtr)

   782 }

   783 # Obsolete

   784 declare 220 generic {

   785     int Tcl_SeekOld(Tcl_Channel chan, int offset, int mode)

   786 }

   787 declare 221 generic {

   788     int Tcl_ServiceAll(void)

   789 }

   790 declare 222 generic {

   791     int Tcl_ServiceEvent(int flags)

   792 }

   793 declare 223 generic {

   794     void Tcl_SetAssocData(Tcl_Interp *interp, CONST char *name,

   795 	    Tcl_InterpDeleteProc *proc, ClientData clientData)

   796 }

   797 declare 224 generic {

   798     void Tcl_SetChannelBufferSize(Tcl_Channel chan, int sz)

   799 }

   800 declare 225 generic {

   801     int Tcl_SetChannelOption(Tcl_Interp *interp, Tcl_Channel chan,

   802 	    CONST char *optionName, CONST char *newValue)

   803 }

   804 declare 226 generic {

   805     int Tcl_SetCommandInfo(Tcl_Interp *interp, CONST char *cmdName,

   806 	    CONST Tcl_CmdInfo *infoPtr)

   807 }

   808 declare 227 generic {

   809     void Tcl_SetErrno(int err)

   810 }

   811 declare 228 generic {

   812     void Tcl_SetErrorCode(Tcl_Interp *interp, ...)

   813 }

   814 declare 229 generic {

   815     void Tcl_SetMaxBlockTime(Tcl_Time *timePtr)

   816 }

   817 declare 230 generic {

   818     void Tcl_SetPanicProc(Tcl_PanicProc *panicProc)

   819 }

   820 declare 231 generic {

   821     int Tcl_SetRecursionLimit(Tcl_Interp *interp, int depth)

   822 }

   823 declare 232 generic {

   824     void Tcl_SetResult(Tcl_Interp *interp, char *str,

   825 	    Tcl_FreeProc *freeProc)

   826 }

   827 declare 233 generic {

   828     int Tcl_SetServiceMode(int mode)

   829 }

   830 declare 234 generic {

   831     void Tcl_SetObjErrorCode(Tcl_Interp *interp, Tcl_Obj *errorObjPtr)

   832 }

   833 declare 235 generic {

   834     void Tcl_SetObjResult(Tcl_Interp *interp, Tcl_Obj *resultObjPtr)

   835 }

   836 declare 236 generic {

   837     void Tcl_SetStdChannel(Tcl_Channel channel, int type)

   838 }

   839 declare 237 generic {

   840     CONST84_RETURN char * Tcl_SetVar(Tcl_Interp *interp, CONST char *varName,

   841 	    CONST char *newValue, int flags)

   842 }

   843 declare 238 generic {

   844     CONST84_RETURN char * Tcl_SetVar2(Tcl_Interp *interp, CONST char *part1,

   845 	    CONST char *part2, CONST char *newValue, int flags)

   846 }

   847 declare 239 generic {

   848     CONST84_RETURN char * Tcl_SignalId(int sig)

   849 }

   850 declare 240 generic {

   851     CONST84_RETURN char * Tcl_SignalMsg(int sig)

   852 }

   853 declare 241 generic {

   854     void Tcl_SourceRCFile(Tcl_Interp *interp)

   855 }

   856 declare 242 generic {

   857     int Tcl_SplitList(Tcl_Interp *interp, CONST char *listStr, int *argcPtr,

   858 	    CONST84 char ***argvPtr)

   859 }

   860 # Obsolete, use Tcl_FSSplitPath

   861 declare 243 generic {

   862     void Tcl_SplitPath(CONST char *path, int *argcPtr, CONST84 char ***argvPtr)

   863 }

   864 declare 244 generic {

   865     void Tcl_StaticPackage(Tcl_Interp *interp, CONST char *pkgName,

   866 	    Tcl_PackageInitProc *initProc, Tcl_PackageInitProc *safeInitProc)

   867 }

   868 declare 245 generic {

   869     int Tcl_StringMatch(CONST char *str, CONST char *pattern)

   870 }

   871 # Obsolete

   872 declare 246 generic {

   873     int Tcl_TellOld(Tcl_Channel chan)

   874 }

   875 declare 247 generic {

   876     int Tcl_TraceVar(Tcl_Interp *interp, CONST char *varName, int flags,

   877 	    Tcl_VarTraceProc *proc, ClientData clientData)

   878 }

   879 declare 248 generic {

   880     int Tcl_TraceVar2(Tcl_Interp *interp, CONST char *part1, CONST char *part2,

   881 	    int flags, Tcl_VarTraceProc *proc, ClientData clientData)

   882 }

   883 declare 249 generic {

   884     char * Tcl_TranslateFileName(Tcl_Interp *interp, CONST char *name,

   885 	    Tcl_DString *bufferPtr)

   886 }

   887 declare 250 generic {

   888     int Tcl_Ungets(Tcl_Channel chan, CONST char *str, int len, int atHead)

   889 }

   890 declare 251 generic {

   891     void Tcl_UnlinkVar(Tcl_Interp *interp, CONST char *varName)

   892 }

   893 declare 252 generic {

   894     int Tcl_UnregisterChannel(Tcl_Interp *interp, Tcl_Channel chan)

   895 }

   896 declare 253 generic {

   897     int Tcl_UnsetVar(Tcl_Interp *interp, CONST char *varName, int flags)

   898 }

   899 declare 254 generic {

   900     int Tcl_UnsetVar2(Tcl_Interp *interp, CONST char *part1, CONST char *part2,

   901 	    int flags)

   902 }

   903 declare 255 generic {

   904     void Tcl_UntraceVar(Tcl_Interp *interp, CONST char *varName, int flags,

   905 	    Tcl_VarTraceProc *proc, ClientData clientData)

   906 }

   907 declare 256 generic {

   908     void Tcl_UntraceVar2(Tcl_Interp *interp, CONST char *part1,

   909 	    CONST char *part2, int flags, Tcl_VarTraceProc *proc,

   910 	    ClientData clientData)

   911 }

   912 declare 257 generic {

   913     void Tcl_UpdateLinkedVar(Tcl_Interp *interp, CONST char *varName)

   914 }

   915 declare 258 generic {

   916     int Tcl_UpVar(Tcl_Interp *interp, CONST char *frameName,

   917 	    CONST char *varName, CONST char *localName, int flags)

   918 }

   919 declare 259 generic {

   920     int Tcl_UpVar2(Tcl_Interp *interp, CONST char *frameName, CONST char *part1,

   921 	    CONST char *part2, CONST char *localName, int flags)

   922 }

   923 declare 260 generic {

   924     int Tcl_VarEval(Tcl_Interp *interp, ...)

   925 }

   926 declare 261 generic {

   927     ClientData Tcl_VarTraceInfo(Tcl_Interp *interp, CONST char *varName,

   928 	    int flags, Tcl_VarTraceProc *procPtr, ClientData prevClientData)

   929 }

   930 declare 262 generic {

   931     ClientData Tcl_VarTraceInfo2(Tcl_Interp *interp, CONST char *part1,

   932 	    CONST char *part2, int flags, Tcl_VarTraceProc *procPtr,

   933 	    ClientData prevClientData)

   934 }

   935 declare 263 generic {

   936     int Tcl_Write(Tcl_Channel chan, CONST char *s, int slen)

   937 }

   938 declare 264 generic {

   939     void Tcl_WrongNumArgs(Tcl_Interp *interp, int objc,

   940 	    Tcl_Obj *CONST objv[], CONST char *message)

   941 }

   942 declare 265 generic {

   943     int Tcl_DumpActiveMemory(CONST char *fileName)

   944 }

   945 declare 266 generic {

   946     void Tcl_ValidateAllMemory(CONST char *file, int line)

   947 }

   949 declare 267 generic {

   950     void Tcl_AppendResultVA(Tcl_Interp *interp, va_list argList)

   951 }

   952 declare 268 generic {

   953     void Tcl_AppendStringsToObjVA(Tcl_Obj *objPtr, va_list argList)

   954 }

   955 declare 269 generic {

   956     CONST84_RETURN char * Tcl_HashStats(Tcl_HashTable *tablePtr)

   957 }

   958 declare 270 generic {

   959     CONST84_RETURN char * Tcl_ParseVar(Tcl_Interp *interp, CONST char *str,

   960 	    CONST84 char **termPtr)

   961 }

   962 declare 271 generic {

   963     CONST84_RETURN char * Tcl_PkgPresent(Tcl_Interp *interp, CONST char *name,

   964 	    CONST char *version, int exact)

   965 }

   966 declare 272 generic {

   967     CONST84_RETURN char * Tcl_PkgPresentEx(Tcl_Interp *interp, CONST char *name,

   968 	    CONST char *version, int exact, ClientData *clientDataPtr)

   969 }

   970 declare 273 generic {

   971     int Tcl_PkgProvide(Tcl_Interp *interp, CONST char *name,

   972 	    CONST char *version)

   973 }

   975 # TIP #268: The internally used new Require function is in slot

   976 #           573. Assuming TCL_TIP268 was activated.

   978 declare 274 generic {

   979     CONST84_RETURN char * Tcl_PkgRequire(Tcl_Interp *interp, CONST char *name,

   980 	    CONST char *version, int exact)

   981 }

   982 declare 275 generic {

   983     void Tcl_SetErrorCodeVA(Tcl_Interp *interp, va_list argList)

   984 }

   985 declare 276 generic {

   986     int  Tcl_VarEvalVA(Tcl_Interp *interp, va_list argList)

   987 }

   988 declare 277 generic {

   989     Tcl_Pid Tcl_WaitPid(Tcl_Pid pid, int *statPtr, int options)

   990 }

   991 declare 278 generic {

   992     void Tcl_PanicVA(CONST char *format, va_list argList)

   993 }

   994 declare 279 generic {

   995     void Tcl_GetVersion(int *major, int *minor, int *patchLevel, int *type)

   996 }

   997 declare 280 generic {

   998     void Tcl_InitMemory(Tcl_Interp *interp)

   999 }

  1001 # Andreas Kupries <a.kupries@westend.com>, 03/21/1999

  1002 # "Trf-Patch for filtering channels"

  1003 #

  1004 # C-Level API for (un)stacking of channels. This allows the introduction

  1005 # of filtering channels with relatively little changes to the core.

  1006 # This patch was created in cooperation with Jan Nijtmans j.nijtmans@chello.nl

  1007 # and is therefore part of his plus-patches too.

  1008 #

  1009 # It would have been possible to place the following definitions according

  1010 # to the alphabetical order used elsewhere in this file, but I decided

  1011 # against that to ease the maintenance of the patch across new tcl versions

  1012 # (patch usually has no problems to integrate the patch file for the last

  1013 # version into the new one).

  1015 declare 281 generic {

  1016     Tcl_Channel Tcl_StackChannel(Tcl_Interp *interp, Tcl_ChannelType *typePtr,

  1017 	    ClientData instanceData, int mask, Tcl_Channel prevChan)

  1018 }

  1019 declare 282 generic {

  1020     int Tcl_UnstackChannel(Tcl_Interp *interp, Tcl_Channel chan)

  1021 }

  1022 declare 283 generic {

  1023     Tcl_Channel Tcl_GetStackedChannel(Tcl_Channel chan)

  1024 }

  1026 # 284 was reserved, but added in 8.4a2

  1027 declare 284 generic {

  1028     void Tcl_SetMainLoop(Tcl_MainLoopProc *proc)

  1029 }

  1031 # Reserved for future use (8.0.x vs. 8.1)

  1032 #  declare 285 generic {

  1033 #  }

  1036 # Added in 8.1:

  1038 declare 286 generic {

  1039     void Tcl_AppendObjToObj(Tcl_Obj *objPtr, Tcl_Obj *appendObjPtr)

  1040 }

  1041 declare 287 generic {

  1042     Tcl_Encoding Tcl_CreateEncoding(Tcl_EncodingType *typePtr)

  1043 }

  1044 declare 288 generic {

  1045     void Tcl_CreateThreadExitHandler(Tcl_ExitProc *proc, ClientData clientData)

  1046 }

  1047 declare 289 generic {

  1048     void Tcl_DeleteThreadExitHandler(Tcl_ExitProc *proc, ClientData clientData)

  1049 }

  1050 declare 290 generic {

  1051     void Tcl_DiscardResult(Tcl_SavedResult *statePtr)

  1052 }

  1053 declare 291 generic {

  1054     int Tcl_EvalEx(Tcl_Interp *interp, CONST char *script, int numBytes,

  1055 	    int flags)

  1056 }

  1057 declare 292 generic {

  1058     int Tcl_EvalObjv(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[],

  1059 	    int flags)

  1060 }

  1061 declare 293 generic {

  1062     int Tcl_EvalObjEx(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags)

  1063 }

  1064 declare 294 generic {

  1065     void Tcl_ExitThread(int status)

  1066 }

  1067 declare 295 generic {

  1068     int Tcl_ExternalToUtf(Tcl_Interp *interp, Tcl_Encoding encoding,

  1069 	    CONST char *src, int srcLen, int flags,

  1070 	    Tcl_EncodingState *statePtr, char *dst, int dstLen,

  1071 	    int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr)

  1072 }

  1073 declare 296 generic {

  1074     char * Tcl_ExternalToUtfDString(Tcl_Encoding encoding,

  1075 	    CONST char *src, int srcLen, Tcl_DString *dsPtr)

  1076 }

  1077 declare 297 generic {

  1078     void Tcl_FinalizeThread(void)

  1079 }

  1080 declare 298 generic {

  1081     void Tcl_FinalizeNotifier(ClientData clientData)

  1082 }

  1083 declare 299 generic {

  1084     void Tcl_FreeEncoding(Tcl_Encoding encoding)

  1085 }

  1086 declare 300 generic {

  1087     Tcl_ThreadId Tcl_GetCurrentThread(void)

  1088 }

  1089 declare 301 generic {

  1090     Tcl_Encoding Tcl_GetEncoding(Tcl_Interp *interp, CONST char *name)

  1091 }

  1092 declare 302 generic {

  1093     CONST84_RETURN char * Tcl_GetEncodingName(Tcl_Encoding encoding)

  1094 }

  1095 declare 303 generic {

  1096     void Tcl_GetEncodingNames(Tcl_Interp *interp)

  1097 }

  1098 declare 304 generic {

  1099     int Tcl_GetIndexFromObjStruct(Tcl_Interp *interp, Tcl_Obj *objPtr,

  1100 	    CONST VOID *tablePtr, int offset, CONST char *msg, int flags,

  1101 	    int *indexPtr)

  1102 }

  1103 declare 305 generic {

  1104     VOID * Tcl_GetThreadData(Tcl_ThreadDataKey *keyPtr, int size)

  1105 }

  1106 declare 306 generic {

  1107     Tcl_Obj * Tcl_GetVar2Ex(Tcl_Interp *interp, CONST char *part1,

  1108 	    CONST char *part2, int flags)

  1109 }

  1110 declare 307 generic {

  1111     ClientData Tcl_InitNotifier(void)

  1112 }

  1113 declare 308 generic {

  1114     void Tcl_MutexLock(Tcl_Mutex *mutexPtr)

  1115 }

  1116 declare 309 generic {

  1117     void Tcl_MutexUnlock(Tcl_Mutex *mutexPtr)

  1118 }

  1119 declare 310 generic {

  1120     void Tcl_ConditionNotify(Tcl_Condition *condPtr)

  1121 }

  1122 declare 311 generic {

  1123     void Tcl_ConditionWait(Tcl_Condition *condPtr, Tcl_Mutex *mutexPtr,

  1124 	    Tcl_Time *timePtr)

  1125 }

  1126 declare 312 generic {

  1127     int Tcl_NumUtfChars(CONST char *src, int len)

  1128 }

  1129 declare 313 generic {

  1130     int Tcl_ReadChars(Tcl_Channel channel, Tcl_Obj *objPtr, int charsToRead,

  1131 	    int appendFlag)

  1132 }

  1133 declare 314 generic {

  1134     void Tcl_RestoreResult(Tcl_Interp *interp, Tcl_SavedResult *statePtr)

  1135 }

  1136 declare 315 generic {

  1137     void Tcl_SaveResult(Tcl_Interp *interp, Tcl_SavedResult *statePtr)

  1138 }

  1139 declare 316 generic {

  1140     int Tcl_SetSystemEncoding(Tcl_Interp *interp, CONST char *name)

  1141 }

  1142 declare 317 generic {

  1143     Tcl_Obj * Tcl_SetVar2Ex(Tcl_Interp *interp, CONST char *part1,

  1144             CONST char *part2, Tcl_Obj *newValuePtr, int flags)

  1145 }

  1146 declare 318 generic {

  1147     void Tcl_ThreadAlert(Tcl_ThreadId threadId)

  1148 }

  1149 declare 319 generic {

  1150     void Tcl_ThreadQueueEvent(Tcl_ThreadId threadId, Tcl_Event* evPtr,

  1151 	    Tcl_QueuePosition position)

  1152 }

  1153 declare 320 generic {

  1154     Tcl_UniChar Tcl_UniCharAtIndex(CONST char *src, int index)

  1155 }

  1156 declare 321 generic {

  1157     Tcl_UniChar Tcl_UniCharToLower(int ch)

  1158 }

  1159 declare 322 generic {

  1160     Tcl_UniChar Tcl_UniCharToTitle(int ch)

  1161 }

  1162 declare 323 generic {

  1163     Tcl_UniChar Tcl_UniCharToUpper(int ch)

  1164 }

  1165 declare 324 generic {

  1166     int Tcl_UniCharToUtf(int ch, char *buf)

  1167 }

  1168 declare 325 generic {

  1169     CONST84_RETURN char * Tcl_UtfAtIndex(CONST char *src, int index)

  1170 }

  1171 declare 326 generic {

  1172     int Tcl_UtfCharComplete(CONST char *src, int len)

  1173 }

  1174 declare 327 generic {

  1175     int Tcl_UtfBackslash(CONST char *src, int *readPtr, char *dst)

  1176 }

  1177 declare 328 generic {

  1178     CONST84_RETURN char * Tcl_UtfFindFirst(CONST char *src, int ch)

  1179 }

  1180 declare 329 generic {

  1181     CONST84_RETURN char * Tcl_UtfFindLast(CONST char *src, int ch)

  1182 }

  1183 declare 330 generic {

  1184     CONST84_RETURN char * Tcl_UtfNext(CONST char *src)

  1185 }

  1186 declare 331 generic {

  1187     CONST84_RETURN char * Tcl_UtfPrev(CONST char *src, CONST char *start)

  1188 }

  1189 declare 332 generic {

  1190     int Tcl_UtfToExternal(Tcl_Interp *interp, Tcl_Encoding encoding,

  1191 	    CONST char *src, int srcLen, int flags,

  1192 	    Tcl_EncodingState *statePtr, char *dst, int dstLen,

  1193 	    int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr)

  1194 }

  1195 declare 333 generic {

  1196     char * Tcl_UtfToExternalDString(Tcl_Encoding encoding,

  1197 	    CONST char *src, int srcLen, Tcl_DString *dsPtr)

  1198 }

  1199 declare 334 generic {

  1200     int Tcl_UtfToLower(char *src)

  1201 }

  1202 declare 335 generic {

  1203     int Tcl_UtfToTitle(char *src)

  1204 }

  1205 declare 336 generic {

  1206     int Tcl_UtfToUniChar(CONST char *src, Tcl_UniChar *chPtr)

  1207 }

  1208 declare 337 generic {

  1209     int Tcl_UtfToUpper(char *src)

  1210 }

  1211 declare 338 generic {

  1212     int Tcl_WriteChars(Tcl_Channel chan, CONST char *src, int srcLen)

  1213 }

  1214 declare 339 generic {

  1215     int Tcl_WriteObj(Tcl_Channel chan, Tcl_Obj *objPtr)

  1216 }

  1217 declare 340 generic {

  1218     char * Tcl_GetString(Tcl_Obj *objPtr)

  1219 }

  1220 declare 341 generic {

  1221     CONST84_RETURN char * Tcl_GetDefaultEncodingDir(void)

  1222 }

  1223 declare 342 generic {

  1224     void Tcl_SetDefaultEncodingDir(CONST char *path)

  1225 }

  1226 declare 343 generic {

  1227     void Tcl_AlertNotifier(ClientData clientData)

  1228 }

  1229 declare 344 generic {

  1230     void Tcl_ServiceModeHook(int mode)

  1231 }

  1232 declare 345 generic {

  1233     int Tcl_UniCharIsAlnum(int ch)

  1234 }

  1235 declare 346 generic {

  1236     int Tcl_UniCharIsAlpha(int ch)

  1237 }

  1238 declare 347 generic {

  1239     int Tcl_UniCharIsDigit(int ch)

  1240 }

  1241 declare 348 generic {

  1242     int Tcl_UniCharIsLower(int ch)

  1243 }

  1244 declare 349 generic {

  1245     int Tcl_UniCharIsSpace(int ch)

  1246 }

  1247 declare 350 generic {

  1248     int Tcl_UniCharIsUpper(int ch)

  1249 }

  1250 declare 351 generic {

  1251     int Tcl_UniCharIsWordChar(int ch)

  1252 }

  1253 declare 352 generic {

  1254     int Tcl_UniCharLen(CONST Tcl_UniChar *str)

  1255 }

  1256 declare 353 generic {

  1257     int Tcl_UniCharNcmp(CONST Tcl_UniChar *cs, CONST Tcl_UniChar *ct,

  1258 	    unsigned long n)

  1259 }

  1260 declare 354 generic {

  1261     char * Tcl_UniCharToUtfDString(CONST Tcl_UniChar *string,

  1262 	    int numChars, Tcl_DString *dsPtr)

  1263 }

  1264 declare 355 generic {

  1265     Tcl_UniChar * Tcl_UtfToUniCharDString(CONST char *string,

  1266 	    int length, Tcl_DString *dsPtr)

  1267 }

  1268 declare 356 generic {

  1269     Tcl_RegExp Tcl_GetRegExpFromObj(Tcl_Interp *interp, Tcl_Obj *patObj,

  1270 	    int flags)

  1271 }

  1273 declare 357 generic {

  1274     Tcl_Obj *Tcl_EvalTokens(Tcl_Interp *interp, Tcl_Token *tokenPtr,

  1275 	    int count)

  1276 }

  1277 declare 358 generic {

  1278     void Tcl_FreeParse(Tcl_Parse *parsePtr)

  1279 }

  1280 declare 359 generic {

  1281     void Tcl_LogCommandInfo(Tcl_Interp *interp, CONST char *script,

  1282 	    CONST char *command, int length)

  1283 }

  1284 declare 360 generic {

  1285     int Tcl_ParseBraces(Tcl_Interp *interp, CONST char *string, int numBytes,

  1286 	    Tcl_Parse *parsePtr, int append, CONST84 char **termPtr)

  1287 }

  1288 declare 361 generic {

  1289     int Tcl_ParseCommand(Tcl_Interp *interp, CONST char *string, int numBytes,

  1290 	    int nested, Tcl_Parse *parsePtr)

  1291 }

  1292 declare 362 generic {

  1293     int Tcl_ParseExpr(Tcl_Interp *interp, CONST char *string, int numBytes,

  1294 	    Tcl_Parse *parsePtr)

  1295 }

  1296 declare 363 generic {

  1297     int Tcl_ParseQuotedString(Tcl_Interp *interp, CONST char *string,

  1298 	    int numBytes, Tcl_Parse *parsePtr, int append,

  1299 	    CONST84 char **termPtr)

  1300 }

  1301 declare 364 generic {

  1302     int Tcl_ParseVarName(Tcl_Interp *interp, CONST char *string, int numBytes,

  1303 	    Tcl_Parse *parsePtr, int append)

  1304 }

  1305 # These 4 functions are obsolete, use Tcl_FSGetCwd, Tcl_FSChdir,

  1306 # Tcl_FSAccess and Tcl_FSStat

  1307 declare 365 generic {

  1308     char *Tcl_GetCwd(Tcl_Interp *interp, Tcl_DString *cwdPtr)

  1309 }

  1310 declare 366 generic {

  1311    int Tcl_Chdir(CONST char *dirName)

  1312 }

  1313 declare 367 generic {

  1314    int Tcl_Access(CONST char *path, int mode)

  1315 }

  1316 declare 368 generic {

  1317     int Tcl_Stat(CONST char *path, struct stat *bufPtr)

  1318 }

  1319 declare 369 generic {

  1320     int Tcl_UtfNcmp(CONST char *s1, CONST char *s2, unsigned long n)

  1321 }

  1322 declare 370 generic {

  1323     int Tcl_UtfNcasecmp(CONST char *s1, CONST char *s2, unsigned long n)

  1324 }

  1325 declare 371 generic {

  1326     int Tcl_StringCaseMatch(CONST char *str, CONST char *pattern, int nocase)

  1327 }

  1328 declare 372 generic {

  1329     int Tcl_UniCharIsControl(int ch)

  1330 }

  1331 declare 373 generic {

  1332     int Tcl_UniCharIsGraph(int ch)

  1333 }

  1334 declare 374 generic {

  1335     int Tcl_UniCharIsPrint(int ch)

  1336 }

  1337 declare 375 generic {

  1338     int Tcl_UniCharIsPunct(int ch)

  1339 }

  1340 declare 376 generic {

  1341     int Tcl_RegExpExecObj(Tcl_Interp *interp, Tcl_RegExp regexp,

  1342 	    Tcl_Obj *objPtr, int offset, int nmatches, int flags)

  1343 }

  1344 declare 377 generic {

  1345     void Tcl_RegExpGetInfo(Tcl_RegExp regexp, Tcl_RegExpInfo *infoPtr)

  1346 }

  1347 declare 378 generic {

  1348     Tcl_Obj * Tcl_NewUnicodeObj(CONST Tcl_UniChar *unicode, int numChars)

  1349 }

  1350 declare 379 generic {

  1351     void Tcl_SetUnicodeObj(Tcl_Obj *objPtr, CONST Tcl_UniChar *unicode,

  1352 	    int numChars)

  1353 }

  1354 declare 380 generic {

  1355     int Tcl_GetCharLength(Tcl_Obj *objPtr)

  1356 }

  1357 declare 381 generic {

  1358     Tcl_UniChar Tcl_GetUniChar(Tcl_Obj *objPtr, int index)

  1359 }

  1360 declare 382 generic {

  1361     Tcl_UniChar * Tcl_GetUnicode(Tcl_Obj *objPtr)

  1362 }

  1363 declare 383 generic {

  1364     Tcl_Obj * Tcl_GetRange(Tcl_Obj *objPtr, int first, int last)

  1365 }

  1366 declare 384 generic {

  1367     void Tcl_AppendUnicodeToObj(Tcl_Obj *objPtr, CONST Tcl_UniChar *unicode,

  1368 	    int length)

  1369 }

  1370 declare 385 generic {

  1371     int Tcl_RegExpMatchObj(Tcl_Interp *interp, Tcl_Obj *stringObj,

  1372 	    Tcl_Obj *patternObj)

  1373 }

  1374 declare 386 generic {

  1375     void Tcl_SetNotifier(Tcl_NotifierProcs *notifierProcPtr)

  1376 }

  1377 declare 387 generic {

  1378     Tcl_Mutex * Tcl_GetAllocMutex(void)

  1379 }

  1380 declare 388 generic {

  1381     int Tcl_GetChannelNames(Tcl_Interp *interp)

  1382 }

  1383 declare 389 generic {

  1384     int Tcl_GetChannelNamesEx(Tcl_Interp *interp, CONST char *pattern)

  1385 }

  1386 declare 390 generic {

  1387     int Tcl_ProcObjCmd(ClientData clientData, Tcl_Interp *interp,

  1388 	    int objc, Tcl_Obj *CONST objv[])

  1389 }

  1390 declare 391 generic {

  1391     void Tcl_ConditionFinalize(Tcl_Condition *condPtr)

  1392 }

  1393 declare 392 generic {

  1394     void Tcl_MutexFinalize(Tcl_Mutex *mutex)

  1395 }

  1396 declare 393 generic {

  1397     int Tcl_CreateThread(Tcl_ThreadId *idPtr, Tcl_ThreadCreateProc proc,

  1398 	    ClientData clientData, int stackSize, int flags)

  1399 }

  1401 # Introduced in 8.3.2

  1402 declare 394 generic {

  1403     int Tcl_ReadRaw(Tcl_Channel chan, char *dst, int bytesToRead)

  1404 }

  1405 declare 395 generic {

  1406     int Tcl_WriteRaw(Tcl_Channel chan, CONST char *src, int srcLen)

  1407 }

  1408 declare 396 generic {

  1409     Tcl_Channel Tcl_GetTopChannel(Tcl_Channel chan)

  1410 }

  1411 declare 397 generic {

  1412     int Tcl_ChannelBuffered(Tcl_Channel chan)

  1413 }

  1414 declare 398 generic {

  1415     CONST84_RETURN char * Tcl_ChannelName(Tcl_ChannelType *chanTypePtr)

  1416 }

  1417 declare 399 generic {

  1418     Tcl_ChannelTypeVersion Tcl_ChannelVersion(Tcl_ChannelType *chanTypePtr)

  1419 }

  1420 declare 400 generic {

  1421     Tcl_DriverBlockModeProc * Tcl_ChannelBlockModeProc(Tcl_ChannelType

  1422 	    *chanTypePtr)

  1423 }

  1424 declare 401 generic {

  1425     Tcl_DriverCloseProc * Tcl_ChannelCloseProc(Tcl_ChannelType *chanTypePtr)

  1426 }

  1427 declare 402 generic {

  1428     Tcl_DriverClose2Proc * Tcl_ChannelClose2Proc(Tcl_ChannelType *chanTypePtr)

  1429 }

  1430 declare 403 generic {

  1431     Tcl_DriverInputProc * Tcl_ChannelInputProc(Tcl_ChannelType *chanTypePtr)

  1432 }

  1433 declare 404 generic {

  1434     Tcl_DriverOutputProc * Tcl_ChannelOutputProc(Tcl_ChannelType *chanTypePtr)

  1435 }

  1436 declare 405 generic {

  1437     Tcl_DriverSeekProc * Tcl_ChannelSeekProc(Tcl_ChannelType *chanTypePtr)

  1438 }

  1439 declare 406 generic {

  1440     Tcl_DriverSetOptionProc * Tcl_ChannelSetOptionProc(Tcl_ChannelType

  1441 	    *chanTypePtr)

  1442 }

  1443 declare 407 generic {

  1444     Tcl_DriverGetOptionProc * Tcl_ChannelGetOptionProc(Tcl_ChannelType

  1445 	    *chanTypePtr)

  1446 }

  1447 declare 408 generic {

  1448     Tcl_DriverWatchProc * Tcl_ChannelWatchProc(Tcl_ChannelType *chanTypePtr)

  1449 }

  1450 declare 409 generic {

  1451     Tcl_DriverGetHandleProc * Tcl_ChannelGetHandleProc(Tcl_ChannelType

  1452 	    *chanTypePtr)

  1453 }

  1454 declare 410 generic {

  1455     Tcl_DriverFlushProc * Tcl_ChannelFlushProc(Tcl_ChannelType *chanTypePtr)

  1456 }

  1457 declare 411 generic {

  1458     Tcl_DriverHandlerProc * Tcl_ChannelHandlerProc(Tcl_ChannelType

  1459 	    *chanTypePtr)

  1460 }

  1462 # Introduced in 8.4a2

  1463 declare 412 generic {

  1464     int Tcl_JoinThread(Tcl_ThreadId threadId, int* result)

  1465 }

  1466 declare 413 generic {

  1467     int Tcl_IsChannelShared(Tcl_Channel channel)

  1468 }

  1469 declare 414 generic {

  1470     int Tcl_IsChannelRegistered(Tcl_Interp* interp, Tcl_Channel channel)

  1471 }

  1472 declare 415 generic {

  1473     void Tcl_CutChannel(Tcl_Channel channel)

  1474 }

  1475 declare 416 generic {

  1476     void Tcl_SpliceChannel(Tcl_Channel channel)

  1477 }

  1478 declare 417 generic {

  1479     void Tcl_ClearChannelHandlers(Tcl_Channel channel)

  1480 }

  1481 declare 418 generic {

  1482     int Tcl_IsChannelExisting(CONST char* channelName)

  1483 }

  1485 declare 419 generic {

  1486     int Tcl_UniCharNcasecmp(CONST Tcl_UniChar *cs, CONST Tcl_UniChar *ct,

  1487 	    unsigned long n)

  1488 }

  1489 declare 420 generic {

  1490     int Tcl_UniCharCaseMatch(CONST Tcl_UniChar *ustr,

  1491 	    CONST Tcl_UniChar *pattern, int nocase)

  1492 }

  1494 declare 421 generic {

  1495     Tcl_HashEntry *Tcl_FindHashEntry(Tcl_HashTable *tablePtr, CONST char *key)

  1496 }

  1498 declare 422 generic {

  1499     Tcl_HashEntry *Tcl_CreateHashEntry(Tcl_HashTable *tablePtr,

  1500 	    CONST char *key, int *newPtr)

  1501 }

  1503 declare 423 generic {

  1504     void Tcl_InitCustomHashTable(Tcl_HashTable *tablePtr, int keyType,

  1505 	    Tcl_HashKeyType *typePtr)

  1506 }

  1508 declare 424 generic {

  1509     void Tcl_InitObjHashTable(Tcl_HashTable *tablePtr)

  1510 }

  1511 declare 425 generic {

  1512     ClientData Tcl_CommandTraceInfo(Tcl_Interp *interp, CONST char *varName,

  1513 	    int flags, Tcl_CommandTraceProc *procPtr,

  1514 	    ClientData prevClientData)

  1515 }

  1516 declare 426 generic {

  1517     int Tcl_TraceCommand(Tcl_Interp *interp, CONST char *varName, int flags,

  1518 	    Tcl_CommandTraceProc *proc, ClientData clientData)

  1519 }

  1520 declare 427 generic {

  1521     void Tcl_UntraceCommand(Tcl_Interp *interp, CONST char *varName,

  1522 	    int flags, Tcl_CommandTraceProc *proc, ClientData clientData)

  1523 }

  1524 declare 428 generic {

  1525     char * Tcl_AttemptAlloc(unsigned int size)

  1526 }

  1527 declare 429 generic {

  1528     char * Tcl_AttemptDbCkalloc(unsigned int size, CONST char *file, int line)

  1529 }

  1530 declare 430 generic {

  1531     char * Tcl_AttemptRealloc(char *ptr, unsigned int size)

  1532 }

  1533 declare 431 generic {

  1534     char * Tcl_AttemptDbCkrealloc(char *ptr, unsigned int size,

  1535 	    CONST char *file, int line)

  1536 }

  1537 declare 432 generic {

  1538     int Tcl_AttemptSetObjLength(Tcl_Obj *objPtr, int length)

  1539 }

  1540 declare 433 generic {

  1541     Tcl_ThreadId Tcl_GetChannelThread(Tcl_Channel channel)

  1542 }

  1543 # introduced in 8.4a3

  1544 declare 434 generic {

  1545     Tcl_UniChar * Tcl_GetUnicodeFromObj(Tcl_Obj *objPtr, int *lengthPtr)

  1546 }

  1547 declare 435 generic {

  1548     int Tcl_GetMathFuncInfo(Tcl_Interp *interp, CONST char *name,

  1549 	    int *numArgsPtr, Tcl_ValueType **argTypesPtr,

  1550 	    Tcl_MathProc **procPtr, ClientData *clientDataPtr)

  1551 }

  1552 declare 436 generic {

  1553     Tcl_Obj * Tcl_ListMathFuncs(Tcl_Interp *interp, CONST char *pattern)

  1554 }

  1555 declare 437 generic {

  1556     Tcl_Obj * Tcl_SubstObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags)

  1557 }

  1558 declare 438 generic {

  1559     int Tcl_DetachChannel(Tcl_Interp* interp, Tcl_Channel channel)

  1560 }

  1561 declare 439 generic {

  1562     int Tcl_IsStandardChannel(Tcl_Channel channel)

  1563 }

  1564 # New functions due to TIP#17

  1565 declare 440 generic {

  1566     int	Tcl_FSCopyFile(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr)

  1567 }

  1568 declare 441 generic {

  1569     int	Tcl_FSCopyDirectory(Tcl_Obj *srcPathPtr,

  1570 	    Tcl_Obj *destPathPtr, Tcl_Obj **errorPtr)

  1571 }

  1572 declare 442 generic {

  1573     int	Tcl_FSCreateDirectory(Tcl_Obj *pathPtr)

  1574 }

  1575 declare 443 generic {

  1576     int	Tcl_FSDeleteFile(Tcl_Obj *pathPtr)

  1577 }

  1578 declare 444 generic {

  1579     int	Tcl_FSLoadFile(Tcl_Interp * interp,

  1580 	    Tcl_Obj *pathPtr, CONST char * sym1, CONST char * sym2,

  1581 	    Tcl_PackageInitProc ** proc1Ptr,

  1582 	    Tcl_PackageInitProc ** proc2Ptr,

  1583 	    Tcl_LoadHandle * handlePtr,

  1584 	    Tcl_FSUnloadFileProc **unloadProcPtr)

  1585 }

  1586 declare 445 generic {

  1587     int	Tcl_FSMatchInDirectory(Tcl_Interp *interp, Tcl_Obj *result,

  1588 	    Tcl_Obj *pathPtr, CONST char *pattern, Tcl_GlobTypeData *types)

  1589 }

  1590 declare 446 generic {

  1591     Tcl_Obj * Tcl_FSLink(Tcl_Obj *pathPtr, Tcl_Obj *toPtr, int linkAction)

  1592 }

  1593 declare 447 generic {

  1594     int Tcl_FSRemoveDirectory(Tcl_Obj *pathPtr,

  1595 	    int recursive, Tcl_Obj **errorPtr)

  1596 }

  1597 declare 448 generic {

  1598     int	Tcl_FSRenameFile(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr)

  1599 }

  1600 declare 449 generic {

  1601     int	Tcl_FSLstat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf)

  1602 }

  1603 declare 450 generic {

  1604     int Tcl_FSUtime(Tcl_Obj *pathPtr, struct utimbuf *tval)

  1605 }

  1606 declare 451 generic {

  1607     int Tcl_FSFileAttrsGet(Tcl_Interp *interp,

  1608 	    int index, Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef)

  1609 }

  1610 declare 452 generic {

  1611     int Tcl_FSFileAttrsSet(Tcl_Interp *interp,

  1612 	    int index, Tcl_Obj *pathPtr, Tcl_Obj *objPtr)

  1613 }

  1614 declare 453 generic {

  1615     CONST char ** Tcl_FSFileAttrStrings(Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef)

  1616 }

  1617 declare 454 generic {

  1618     int Tcl_FSStat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf)

  1619 }

  1620 declare 455 generic {

  1621     int Tcl_FSAccess(Tcl_Obj *pathPtr, int mode)

  1622 }

  1623 declare 456 generic {

  1624     Tcl_Channel Tcl_FSOpenFileChannel(Tcl_Interp *interp, Tcl_Obj *pathPtr,

  1625 	    CONST char *modeString, int permissions)

  1626 }

  1627 declare 457 generic {

  1628     Tcl_Obj*  Tcl_FSGetCwd(Tcl_Interp *interp)

  1629 }

  1630 declare 458 generic {

  1631     int Tcl_FSChdir(Tcl_Obj *pathPtr)

  1632 }

  1633 declare 459 generic {

  1634     int Tcl_FSConvertToPathType(Tcl_Interp *interp, Tcl_Obj *pathPtr)

  1635 }

  1636 declare 460 generic {

  1637     Tcl_Obj* Tcl_FSJoinPath(Tcl_Obj *listObj, int elements)

  1638 }

  1639 declare 461 generic {

  1640     Tcl_Obj* Tcl_FSSplitPath(Tcl_Obj* pathPtr, int *lenPtr)

  1641 }

  1642 declare 462 generic {

  1643     int Tcl_FSEqualPaths(Tcl_Obj* firstPtr, Tcl_Obj* secondPtr)

  1644 }

  1645 declare 463 generic {

  1646     Tcl_Obj* Tcl_FSGetNormalizedPath(Tcl_Interp *interp, Tcl_Obj* pathObjPtr)

  1647 }

  1648 declare 464 generic {

  1649     Tcl_Obj* Tcl_FSJoinToPath(Tcl_Obj *basePtr, int objc,

  1650 	    Tcl_Obj *CONST objv[])

  1651 }

  1652 declare 465 generic {

  1653     ClientData Tcl_FSGetInternalRep(Tcl_Obj* pathObjPtr,

  1654 	    Tcl_Filesystem *fsPtr)

  1655 }

  1656 declare 466 generic {

  1657     Tcl_Obj* Tcl_FSGetTranslatedPath(Tcl_Interp *interp, Tcl_Obj* pathPtr)

  1658 }

  1659 declare 467 generic {

  1660     int Tcl_FSEvalFile(Tcl_Interp *interp, Tcl_Obj *fileName)

  1661 }

  1662 declare 468 generic {

  1663     Tcl_Obj* Tcl_FSNewNativePath(Tcl_Filesystem* fromFilesystem,

  1664 	    ClientData clientData)

  1665 }

  1666 declare 469 generic {

  1667     CONST char* Tcl_FSGetNativePath(Tcl_Obj* pathObjPtr)

  1668 }

  1669 declare 470 generic {

  1670     Tcl_Obj* Tcl_FSFileSystemInfo(Tcl_Obj* pathObjPtr)

  1671 }

  1672 declare 471 generic {

  1673     Tcl_Obj* Tcl_FSPathSeparator(Tcl_Obj* pathObjPtr)

  1674 }

  1675 declare 472 generic {

  1676     Tcl_Obj* Tcl_FSListVolumes(void)

  1677 }

  1678 declare 473 generic {

  1679     int Tcl_FSRegister(ClientData clientData, Tcl_Filesystem *fsPtr)

  1680 }

  1681 declare 474 generic {

  1682     int Tcl_FSUnregister(Tcl_Filesystem *fsPtr)

  1683 }

  1684 declare 475 generic {

  1685     ClientData Tcl_FSData(Tcl_Filesystem *fsPtr)

  1686 }

  1687 declare 476 generic {

  1688     CONST char* Tcl_FSGetTranslatedStringPath(Tcl_Interp *interp,

  1689 	    Tcl_Obj* pathPtr)

  1690 }

  1691 declare 477 generic {

  1692     Tcl_Filesystem* Tcl_FSGetFileSystemForPath(Tcl_Obj* pathObjPtr)

  1693 }

  1694 declare 478 generic {

  1695     Tcl_PathType Tcl_FSGetPathType(Tcl_Obj *pathObjPtr)

  1696 }

  1697 # New function due to TIP#49

  1698 declare 479 generic {

  1699     int Tcl_OutputBuffered(Tcl_Channel chan)

  1700 }

  1701 declare 480 generic {

  1702     void Tcl_FSMountsChanged(Tcl_Filesystem *fsPtr)

  1703 }

  1704 # New function due to TIP#56

  1705 declare 481 generic {

  1706     int Tcl_EvalTokensStandard(Tcl_Interp *interp, Tcl_Token *tokenPtr,

  1707 	    int count)

  1708 }

  1710 # New export due to TIP#73

  1711 declare 482 generic {

  1712     void Tcl_GetTime(Tcl_Time* timeBuf)

  1713 }

  1715 # New exports due to TIP#32

  1717 declare 483 generic {

  1718     Tcl_Trace Tcl_CreateObjTrace(Tcl_Interp* interp, int level, int flags,

  1719 	    Tcl_CmdObjTraceProc* objProc, ClientData clientData,

  1720 	    Tcl_CmdObjTraceDeleteProc* delProc)

  1721 }

  1722 declare 484 generic {

  1723     int Tcl_GetCommandInfoFromToken(Tcl_Command token, Tcl_CmdInfo* infoPtr)

  1724 }

  1725 declare 485 generic {

  1726     int Tcl_SetCommandInfoFromToken(Tcl_Command token,

  1727 	    CONST Tcl_CmdInfo* infoPtr)

  1728 }

  1730 ### New functions on 64-bit dev branch ###

  1731 declare 486 generic {

  1732     Tcl_Obj * Tcl_DbNewWideIntObj(Tcl_WideInt wideValue,

  1733 	    CONST char *file, int line)

  1734 }

  1735 declare 487 generic {

  1736     int Tcl_GetWideIntFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,

  1737 	    Tcl_WideInt *widePtr)

  1738 }

  1739 declare 488 generic {

  1740     Tcl_Obj * Tcl_NewWideIntObj(Tcl_WideInt wideValue)

  1741 }

  1742 declare 489 generic {

  1743     void Tcl_SetWideIntObj(Tcl_Obj *objPtr, Tcl_WideInt wideValue)

  1744 }

  1745 declare 490 generic {

  1746     Tcl_StatBuf * Tcl_AllocStatBuf(void)

  1747 }

  1748 declare 491 generic {

  1749     Tcl_WideInt Tcl_Seek(Tcl_Channel chan, Tcl_WideInt offset, int mode)

  1750 }

  1751 declare 492 generic {

  1752     Tcl_WideInt Tcl_Tell(Tcl_Channel chan)

  1753 }

  1755 # New export due to TIP#91

  1756 declare 493 generic {

  1757     Tcl_DriverWideSeekProc * Tcl_ChannelWideSeekProc(

  1758 	    Tcl_ChannelType *chanTypePtr)

  1759 }

  1761 # Slots 494 to 553 are taken already by 8.5

  1762 # #111 - Dicts            (494 ... 504)

  1763 #  #59 - Config           (505)

  1764 # #139 - Namespace API    (506 ... 517)

  1765 # #137 - source -encoding (518)

  1766 # #121 - ExitProc         (519)

  1767 # #121 - Resource Limits  (520 ... 534)

  1768 # #226 - S/R Interp State (535 ... 537)

  1769 # #227 - S/G Return Opts  (538 ... 539)

  1770 # #235 - Ensemble C API   (540 ... 551)

  1771 # #233 - Virtualized Time (552 ... 553)

  1773 # TIP#218 (Driver Thread Actions) davygrvy/akupries ChannelType ver 4

  1774 # These slots are used by 8.5 as well.

  1775 declare 554 generic {

  1776     Tcl_DriverThreadActionProc *Tcl_ChannelThreadActionProc(Tcl_ChannelType *chanTypePtr)

  1777 }

  1779 # Slots 555 to 572 are taken already by 8.5

  1780 # TIP #237: Arbitrary-prec Integers (555 ... 559)

  1781 # TIP #208: 'chan' Command          (560 ... 561)

  1782 # TIP #219: Channel Reflection      (562 ... 565)

  1783 # TIP #237: Add. bignum support     (566)

  1784 # TIP #181: 'namespace unknown' Cmd (567 ... 568)

  1785 # TIP #258: Enhanced Encodings API  (569 ... 572)

  1787 # TIP#268: Extended version numbers and requirements.

  1788 #          The slot is present even if TCL_TIP268 is not activated.

  1790 declare 573 generic {

  1791     int Tcl_PkgRequireProc(Tcl_Interp *interp, CONST char *name,

  1792 	    int objc, Tcl_Obj *CONST objv[], ClientData *clientDataPtr)

  1793 }

  1795 ##############################################################################

  1797 # Define the platform specific public Tcl interface.  These functions are

  1798 # only available on the designated platform.

  1800 interface tclPlat

  1802 ######################

  1803 # Windows declarations

  1805 # Added in Tcl 8.1

  1807 declare 0 win {

  1808     TCHAR * Tcl_WinUtfToTChar(CONST char *str, int len, Tcl_DString *dsPtr)

  1809 }

  1810 declare 1 win {

  1811     char * Tcl_WinTCharToUtf(CONST TCHAR *str, int len, Tcl_DString *dsPtr)

  1812 }

  1814 ##################

  1815 # Mac declarations

  1817 # This is needed by the shells to handle Macintosh events.

  1819 declare 0 mac {

  1820     void Tcl_MacSetEventProc(Tcl_MacConvertEventPtr procPtr)

  1821 }

  1823 # These routines are useful for handling using scripts from resources

  1824 # in the application shell

  1826 declare 1 mac {

  1827     char * Tcl_MacConvertTextResource(Handle resource)

  1828 }

  1829 declare 2 mac {

  1830     int Tcl_MacEvalResource(Tcl_Interp *interp, CONST char *resourceName,

  1831 	    int resourceNumber, CONST char *fileName)

  1832 }

  1833 declare 3 mac {

  1834     Handle Tcl_MacFindResource(Tcl_Interp *interp, long resourceType,

  1835 	    CONST char *resourceName, int resourceNumber,

  1836 	    CONST char *resFileRef, int * releaseIt)

  1837 }

  1839 # These routines support the new OSType object type (i.e. the packed 4

  1840 # character type and creator codes).

  1842 declare 4 mac {

  1843     int Tcl_GetOSTypeFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr,

  1844 	    OSType *osTypePtr)

  1845 }

  1846 declare 5 mac {

  1847     void Tcl_SetOSTypeObj(Tcl_Obj *objPtr, OSType osType)

  1848 }

  1849 declare 6 mac {

  1850     Tcl_Obj * Tcl_NewOSTypeObj(OSType osType)

  1851 }

  1853 # These are not in MSL 2.1.2, so we need to export them from the

  1854 # Tcl shared library.  They are found in the compat directory.

  1856 declare 7 mac {

  1857     int strncasecmp(CONST char *s1, CONST char *s2, size_t n)

  1858 }

  1859 declare 8 mac {

  1860     int strcasecmp(CONST char *s1, CONST char *s2)

  1861 }

  1863 ##################

  1864 # Mac OS X declarations

  1865 #

  1867 declare 0 macosx {

  1868     int Tcl_MacOSXOpenBundleResources(Tcl_Interp *interp,

  1869 	    CONST char *bundleName,

  1870 	    int hasResourceFile,

  1871 	    int maxPathLen,

  1872 	    char *libraryPath)

  1873 }

  1874 declare 1 macosx {

  1875     int Tcl_MacOSXOpenVersionedBundleResources(Tcl_Interp *interp,

  1876 	    CONST char *bundleName,

  1877 	    CONST char *bundleVersion,

  1878 	    int hasResourceFile,

  1879 	    int maxPathLen,

  1880 	    char *libraryPath)

  1881 }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--