1# tclInt.decls -- 2# 3# This file contains the declarations for all unsupported 4# functions that are exported by the Tcl library. This file 5# is used to generate the tclIntDecls.h, tclIntPlatDecls.h, 6# tclIntStub.c, tclPlatStub.c, tclCompileDecls.h and tclCompileStub.c 7# files 8# 9# Copyright (c) 1998-1999 by Scriptics Corporation. 10# Copyright (c) 2001 by Kevin B. Kenny. All rights reserved. 11# 12# See the file "license.terms" for information on usage and redistribution 13# of this file, and for a DISCLAIMER OF ALL WARRANTIES. 14# 15# RCS: @(#) $Id: tclInt.decls,v 1.59.2.7 2007/04/21 19:52:14 kennykb Exp $ 16 17library tcl 18 19# Define the unsupported generic interfaces. 20 21interface tclInt 22 23# Declare each of the functions in the unsupported internal Tcl 24# interface. These interfaces are allowed to changed between versions. 25# Use at your own risk. Note that the position of functions should not 26# be changed between versions to avoid gratuitous incompatibilities. 27 28# Replaced by Tcl_FSAccess in 8.4: 29#declare 0 generic { 30# int TclAccess(CONST char *path, int mode) 31#} 32declare 1 generic { 33 int TclAccessDeleteProc(TclAccessProc_ *proc) 34} 35declare 2 generic { 36 int TclAccessInsertProc(TclAccessProc_ *proc) 37} 38declare 3 generic { 39 void TclAllocateFreeObjects(void) 40} 41# Replaced by TclpChdir in 8.1: 42# declare 4 generic { 43# int TclChdir(Tcl_Interp *interp, char *dirName) 44# } 45declare 5 {unix win} { 46 int TclCleanupChildren(Tcl_Interp *interp, int numPids, Tcl_Pid *pidPtr, 47 Tcl_Channel errorChan) 48} 49declare 6 generic { 50 void TclCleanupCommand(Command *cmdPtr) 51} 52declare 7 generic { 53 int TclCopyAndCollapse(int count, CONST char *src, char *dst) 54} 55declare 8 generic { 56 int TclCopyChannel(Tcl_Interp *interp, Tcl_Channel inChan, 57 Tcl_Channel outChan, int toRead, Tcl_Obj *cmdPtr) 58} 59 60# TclCreatePipeline unofficially exported for use by BLT. 61 62declare 9 {unix win} { 63 int TclCreatePipeline(Tcl_Interp *interp, int argc, CONST char **argv, 64 Tcl_Pid **pidArrayPtr, TclFile *inPipePtr, TclFile *outPipePtr, 65 TclFile *errFilePtr) 66} 67declare 10 generic { 68 int TclCreateProc(Tcl_Interp *interp, Namespace *nsPtr, 69 CONST char *procName, 70 Tcl_Obj *argsPtr, Tcl_Obj *bodyPtr, Proc **procPtrPtr) 71} 72declare 11 generic { 73 void TclDeleteCompiledLocalVars(Interp *iPtr, CallFrame *framePtr) 74} 75declare 12 generic { 76 void TclDeleteVars(Interp *iPtr, Tcl_HashTable *tablePtr) 77} 78declare 13 generic { 79 int TclDoGlob(Tcl_Interp *interp, char *separators, 80 Tcl_DString *headPtr, char *tail, Tcl_GlobTypeData *types) 81} 82declare 14 generic { 83 void TclDumpMemoryInfo(FILE *outFile) 84} 85# Removed in 8.1: 86# declare 15 generic { 87# void TclExpandParseValue(ParseValue *pvPtr, int needed) 88# } 89declare 16 generic { 90 void TclExprFloatError(Tcl_Interp *interp, double value) 91} 92# Removed in 8.4 93#declare 17 generic { 94# int TclFileAttrsCmd(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) 95#} 96#declare 18 generic { 97# int TclFileCopyCmd(Tcl_Interp *interp, int argc, char **argv) 98#} 99#declare 19 generic { 100# int TclFileDeleteCmd(Tcl_Interp *interp, int argc, char **argv) 101#} 102#declare 20 generic { 103# int TclFileMakeDirsCmd(Tcl_Interp *interp, int argc, char **argv) 104#} 105#declare 21 generic { 106# int TclFileRenameCmd(Tcl_Interp *interp, int argc, char **argv) 107#} 108declare 22 generic { 109 int TclFindElement(Tcl_Interp *interp, CONST char *listStr, 110 int listLength, CONST char **elementPtr, CONST char **nextPtr, 111 int *sizePtr, int *bracePtr) 112} 113declare 23 generic { 114 Proc * TclFindProc(Interp *iPtr, CONST char *procName) 115} 116declare 24 generic { 117 int TclFormatInt(char *buffer, long n) 118} 119declare 25 generic { 120 void TclFreePackageInfo(Interp *iPtr) 121} 122# Removed in 8.1: 123# declare 26 generic { 124# char * TclGetCwd(Tcl_Interp *interp) 125# } 126declare 27 generic { 127 int TclGetDate(char *p, Tcl_WideInt now, long zone, 128 Tcl_WideInt *timePtr) 129} 130declare 28 generic { 131 Tcl_Channel TclpGetDefaultStdChannel(int type) 132} 133# Removed in 8.4b2: 134#declare 29 generic { 135# Tcl_Obj * TclGetElementOfIndexedArray(Tcl_Interp *interp, 136# int localIndex, Tcl_Obj *elemPtr, int flags) 137#} 138# Replaced by char * TclGetEnv(CONST char *name, Tcl_DString *valuePtr) in 8.1: 139# declare 30 generic { 140# char * TclGetEnv(CONST char *name) 141# } 142declare 31 generic { 143 char * TclGetExtension(char *name) 144} 145declare 32 generic { 146 int TclGetFrame(Tcl_Interp *interp, CONST char *str, 147 CallFrame **framePtrPtr) 148} 149declare 33 generic { 150 TclCmdProcType TclGetInterpProc(void) 151} 152declare 34 generic { 153 int TclGetIntForIndex(Tcl_Interp *interp, Tcl_Obj *objPtr, 154 int endValue, int *indexPtr) 155} 156# Removed in 8.4b2: 157#declare 35 generic { 158# Tcl_Obj * TclGetIndexedScalar(Tcl_Interp *interp, int localIndex, 159# int flags) 160#} 161declare 36 generic { 162 int TclGetLong(Tcl_Interp *interp, CONST char *str, long *longPtr) 163} 164declare 37 generic { 165 int TclGetLoadedPackages(Tcl_Interp *interp, char *targetName) 166} 167declare 38 generic { 168 int TclGetNamespaceForQualName(Tcl_Interp *interp, CONST char *qualName, 169 Namespace *cxtNsPtr, int flags, Namespace **nsPtrPtr, 170 Namespace **altNsPtrPtr, Namespace **actualCxtPtrPtr, 171 CONST char **simpleNamePtr) 172} 173declare 39 generic { 174 TclObjCmdProcType TclGetObjInterpProc(void) 175} 176declare 40 generic { 177 int TclGetOpenMode(Tcl_Interp *interp, CONST char *str, int *seekFlagPtr) 178} 179declare 41 generic { 180 Tcl_Command TclGetOriginalCommand(Tcl_Command command) 181} 182declare 42 generic { 183 char * TclpGetUserHome(CONST char *name, Tcl_DString *bufferPtr) 184} 185declare 43 generic { 186 int TclGlobalInvoke(Tcl_Interp *interp, int argc, CONST84 char **argv, int flags) 187} 188declare 44 generic { 189 int TclGuessPackageName(CONST char *fileName, Tcl_DString *bufPtr) 190} 191declare 45 generic { 192 int TclHideUnsafeCommands(Tcl_Interp *interp) 193} 194declare 46 generic { 195 int TclInExit(void) 196} 197# Removed in 8.4b2: 198#declare 47 generic { 199# Tcl_Obj * TclIncrElementOfIndexedArray(Tcl_Interp *interp, 200# int localIndex, Tcl_Obj *elemPtr, long incrAmount) 201#} 202# Removed in 8.4b2: 203#declare 48 generic { 204# Tcl_Obj * TclIncrIndexedScalar(Tcl_Interp *interp, int localIndex, 205# long incrAmount) 206#} 207declare 49 generic { 208 Tcl_Obj * TclIncrVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr, 209 Tcl_Obj *part2Ptr, long incrAmount, int part1NotParsed) 210} 211declare 50 generic { 212 void TclInitCompiledLocals(Tcl_Interp *interp, CallFrame *framePtr, 213 Namespace *nsPtr) 214} 215declare 51 generic { 216 int TclInterpInit(Tcl_Interp *interp) 217} 218declare 52 generic { 219 int TclInvoke(Tcl_Interp *interp, int argc, CONST84 char **argv, int flags) 220} 221declare 53 generic { 222 int TclInvokeObjectCommand(ClientData clientData, Tcl_Interp *interp, 223 int argc, CONST84 char **argv) 224} 225declare 54 generic { 226 int TclInvokeStringCommand(ClientData clientData, Tcl_Interp *interp, 227 int objc, Tcl_Obj *CONST objv[]) 228} 229declare 55 generic { 230 Proc * TclIsProc(Command *cmdPtr) 231} 232# Replaced with TclpLoadFile in 8.1: 233# declare 56 generic { 234# int TclLoadFile(Tcl_Interp *interp, char *fileName, char *sym1, 235# char *sym2, Tcl_PackageInitProc **proc1Ptr, 236# Tcl_PackageInitProc **proc2Ptr) 237# } 238# Signature changed to take a length in 8.1: 239# declare 57 generic { 240# int TclLooksLikeInt(char *p) 241# } 242declare 58 generic { 243 Var * TclLookupVar(Tcl_Interp *interp, CONST char *part1, CONST char *part2, 244 int flags, CONST char *msg, int createPart1, int createPart2, 245 Var **arrayPtrPtr) 246} 247# Replaced by Tcl_FSMatchInDirectory in 8.4 248#declare 59 generic { 249# int TclpMatchFiles(Tcl_Interp *interp, char *separators, 250# Tcl_DString *dirPtr, char *pattern, char *tail) 251#} 252declare 60 generic { 253 int TclNeedSpace(CONST char *start, CONST char *end) 254} 255declare 61 generic { 256 Tcl_Obj * TclNewProcBodyObj(Proc *procPtr) 257} 258declare 62 generic { 259 int TclObjCommandComplete(Tcl_Obj *cmdPtr) 260} 261declare 63 generic { 262 int TclObjInterpProc(ClientData clientData, Tcl_Interp *interp, 263 int objc, Tcl_Obj *CONST objv[]) 264} 265declare 64 generic { 266 int TclObjInvoke(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], 267 int flags) 268} 269declare 65 generic { 270 int TclObjInvokeGlobal(Tcl_Interp *interp, int objc, 271 Tcl_Obj *CONST objv[], int flags) 272} 273declare 66 generic { 274 int TclOpenFileChannelDeleteProc(TclOpenFileChannelProc_ *proc) 275} 276declare 67 generic { 277 int TclOpenFileChannelInsertProc(TclOpenFileChannelProc_ *proc) 278} 279# Replaced by Tcl_FSAccess in 8.4: 280#declare 68 generic { 281# int TclpAccess(CONST char *path, int mode) 282#} 283declare 69 generic { 284 char * TclpAlloc(unsigned int size) 285} 286#declare 70 generic { 287# int TclpCopyFile(CONST char *source, CONST char *dest) 288#} 289#declare 71 generic { 290# int TclpCopyDirectory(CONST char *source, CONST char *dest, 291# Tcl_DString *errorPtr) 292#} 293#declare 72 generic { 294# int TclpCreateDirectory(CONST char *path) 295#} 296#declare 73 generic { 297# int TclpDeleteFile(CONST char *path) 298#} 299declare 74 generic { 300 void TclpFree(char *ptr) 301} 302declare 75 generic { 303 unsigned long TclpGetClicks(void) 304} 305declare 76 generic { 306 unsigned long TclpGetSeconds(void) 307} 308 309# deprecated 310declare 77 generic { 311 void TclpGetTime(Tcl_Time *time) 312} 313 314declare 78 generic { 315 int TclpGetTimeZone(Tcl_WideInt time) 316} 317# Replaced by Tcl_FSListVolumes in 8.4: 318#declare 79 generic { 319# int TclpListVolumes(Tcl_Interp *interp) 320#} 321# Replaced by Tcl_FSOpenFileChannel in 8.4: 322#declare 80 generic { 323# Tcl_Channel TclpOpenFileChannel(Tcl_Interp *interp, char *fileName, 324# char *modeString, int permissions) 325#} 326declare 81 generic { 327 char * TclpRealloc(char *ptr, unsigned int size) 328} 329#declare 82 generic { 330# int TclpRemoveDirectory(CONST char *path, int recursive, 331# Tcl_DString *errorPtr) 332#} 333#declare 83 generic { 334# int TclpRenameFile(CONST char *source, CONST char *dest) 335#} 336# Removed in 8.1: 337# declare 84 generic { 338# int TclParseBraces(Tcl_Interp *interp, char *str, char **termPtr, 339# ParseValue *pvPtr) 340# } 341# declare 85 generic { 342# int TclParseNestedCmd(Tcl_Interp *interp, char *str, int flags, 343# char **termPtr, ParseValue *pvPtr) 344# } 345# declare 86 generic { 346# int TclParseQuotes(Tcl_Interp *interp, char *str, int termChar, 347# int flags, char **termPtr, ParseValue *pvPtr) 348# } 349# declare 87 generic { 350# void TclPlatformInit(Tcl_Interp *interp) 351# } 352declare 88 generic { 353 char * TclPrecTraceProc(ClientData clientData, Tcl_Interp *interp, 354 CONST char *name1, CONST char *name2, int flags) 355} 356declare 89 generic { 357 int TclPreventAliasLoop(Tcl_Interp *interp, Tcl_Interp *cmdInterp, 358 Tcl_Command cmd) 359} 360# Removed in 8.1 (only available if compiled with TCL_COMPILE_DEBUG): 361# declare 90 generic { 362# void TclPrintByteCodeObj(Tcl_Interp *interp, Tcl_Obj *objPtr) 363# } 364declare 91 generic { 365 void TclProcCleanupProc(Proc *procPtr) 366} 367declare 92 generic { 368 int TclProcCompileProc(Tcl_Interp *interp, Proc *procPtr, 369 Tcl_Obj *bodyPtr, Namespace *nsPtr, CONST char *description, 370 CONST char *procName) 371} 372declare 93 generic { 373 void TclProcDeleteProc(ClientData clientData) 374} 375declare 94 generic { 376 int TclProcInterpProc(ClientData clientData, Tcl_Interp *interp, 377 int argc, CONST84 char **argv) 378} 379# Replaced by Tcl_FSStat in 8.4: 380#declare 95 generic { 381# int TclpStat(CONST char *path, Tcl_StatBuf *buf) 382#} 383declare 96 generic { 384 int TclRenameCommand(Tcl_Interp *interp, char *oldName, char *newName) 385} 386declare 97 generic { 387 void TclResetShadowedCmdRefs(Tcl_Interp *interp, Command *newCmdPtr) 388} 389declare 98 generic { 390 int TclServiceIdle(void) 391} 392# Removed in 8.4b2: 393#declare 99 generic { 394# Tcl_Obj * TclSetElementOfIndexedArray(Tcl_Interp *interp, int localIndex, 395# Tcl_Obj *elemPtr, Tcl_Obj *objPtr, int flags) 396#} 397# Removed in 8.4b2: 398#declare 100 generic { 399# Tcl_Obj * TclSetIndexedScalar(Tcl_Interp *interp, int localIndex, 400# Tcl_Obj *objPtr, int flags) 401#} 402declare 101 generic { 403 char * TclSetPreInitScript(char *string) 404} 405declare 102 generic { 406 void TclSetupEnv(Tcl_Interp *interp) 407} 408declare 103 generic { 409 int TclSockGetPort(Tcl_Interp *interp, char *str, char *proto, 410 int *portPtr) 411} 412declare 104 {unix win} { 413 int TclSockMinimumBuffers(int sock, int size) 414} 415# Replaced by Tcl_FSStat in 8.4: 416#declare 105 generic { 417# int TclStat(CONST char *path, Tcl_StatBuf *buf) 418#} 419declare 106 generic { 420 int TclStatDeleteProc(TclStatProc_ *proc) 421} 422declare 107 generic { 423 int TclStatInsertProc(TclStatProc_ *proc) 424} 425declare 108 generic { 426 void TclTeardownNamespace(Namespace *nsPtr) 427} 428declare 109 generic { 429 int TclUpdateReturnInfo(Interp *iPtr) 430} 431# Removed in 8.1: 432# declare 110 generic { 433# char * TclWordEnd(char *start, char *lastChar, int nested, int *semiPtr) 434# } 435 436# Procedures used in conjunction with Tcl namespaces. They are 437# defined here instead of in tcl.decls since they are not stable yet. 438 439declare 111 generic { 440 void Tcl_AddInterpResolvers(Tcl_Interp *interp, CONST char *name, 441 Tcl_ResolveCmdProc *cmdProc, Tcl_ResolveVarProc *varProc, 442 Tcl_ResolveCompiledVarProc *compiledVarProc) 443} 444declare 112 generic { 445 int Tcl_AppendExportList(Tcl_Interp *interp, Tcl_Namespace *nsPtr, 446 Tcl_Obj *objPtr) 447} 448declare 113 generic { 449 Tcl_Namespace * Tcl_CreateNamespace(Tcl_Interp *interp, CONST char *name, 450 ClientData clientData, Tcl_NamespaceDeleteProc *deleteProc) 451} 452declare 114 generic { 453 void Tcl_DeleteNamespace(Tcl_Namespace *nsPtr) 454} 455declare 115 generic { 456 int Tcl_Export(Tcl_Interp *interp, Tcl_Namespace *nsPtr, 457 CONST char *pattern, int resetListFirst) 458} 459declare 116 generic { 460 Tcl_Command Tcl_FindCommand(Tcl_Interp *interp, CONST char *name, 461 Tcl_Namespace *contextNsPtr, int flags) 462} 463declare 117 generic { 464 Tcl_Namespace * Tcl_FindNamespace(Tcl_Interp *interp, CONST char *name, 465 Tcl_Namespace *contextNsPtr, int flags) 466} 467declare 118 generic { 468 int Tcl_GetInterpResolvers(Tcl_Interp *interp, CONST char *name, 469 Tcl_ResolverInfo *resInfo) 470} 471declare 119 generic { 472 int Tcl_GetNamespaceResolvers(Tcl_Namespace *namespacePtr, 473 Tcl_ResolverInfo *resInfo) 474} 475declare 120 generic { 476 Tcl_Var Tcl_FindNamespaceVar(Tcl_Interp *interp, CONST char *name, 477 Tcl_Namespace *contextNsPtr, int flags) 478} 479declare 121 generic { 480 int Tcl_ForgetImport(Tcl_Interp *interp, Tcl_Namespace *nsPtr, 481 CONST char *pattern) 482} 483declare 122 generic { 484 Tcl_Command Tcl_GetCommandFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr) 485} 486declare 123 generic { 487 void Tcl_GetCommandFullName(Tcl_Interp *interp, Tcl_Command command, 488 Tcl_Obj *objPtr) 489} 490declare 124 generic { 491 Tcl_Namespace * Tcl_GetCurrentNamespace(Tcl_Interp *interp) 492} 493declare 125 generic { 494 Tcl_Namespace * Tcl_GetGlobalNamespace(Tcl_Interp *interp) 495} 496declare 126 generic { 497 void Tcl_GetVariableFullName(Tcl_Interp *interp, Tcl_Var variable, 498 Tcl_Obj *objPtr) 499} 500declare 127 generic { 501 int Tcl_Import(Tcl_Interp *interp, Tcl_Namespace *nsPtr, 502 CONST char *pattern, int allowOverwrite) 503} 504declare 128 generic { 505 void Tcl_PopCallFrame(Tcl_Interp* interp) 506} 507declare 129 generic { 508 int Tcl_PushCallFrame(Tcl_Interp* interp, Tcl_CallFrame *framePtr, 509 Tcl_Namespace *nsPtr, int isProcCallFrame) 510} 511declare 130 generic { 512 int Tcl_RemoveInterpResolvers(Tcl_Interp *interp, CONST char *name) 513} 514declare 131 generic { 515 void Tcl_SetNamespaceResolvers(Tcl_Namespace *namespacePtr, 516 Tcl_ResolveCmdProc *cmdProc, Tcl_ResolveVarProc *varProc, 517 Tcl_ResolveCompiledVarProc *compiledVarProc) 518} 519declare 132 generic { 520 int TclpHasSockets(Tcl_Interp *interp) 521} 522declare 133 generic { 523 struct tm * TclpGetDate(TclpTime_t time, int useGMT) 524} 525declare 134 generic { 526 size_t TclpStrftime(char *s, size_t maxsize, CONST char *format, 527 CONST struct tm *t, int useGMT) 528} 529declare 135 generic { 530 int TclpCheckStackSpace(void) 531} 532 533# Added in 8.1: 534 535#declare 137 generic { 536# int TclpChdir(CONST char *dirName) 537#} 538declare 138 generic { 539 CONST84_RETURN char * TclGetEnv(CONST char *name, Tcl_DString *valuePtr) 540} 541#declare 139 generic { 542# int TclpLoadFile(Tcl_Interp *interp, char *fileName, char *sym1, 543# char *sym2, Tcl_PackageInitProc **proc1Ptr, 544# Tcl_PackageInitProc **proc2Ptr, ClientData *clientDataPtr) 545#} 546declare 140 generic { 547 int TclLooksLikeInt(CONST char *bytes, int length) 548} 549# This is used by TclX, but should otherwise be considered private 550declare 141 generic { 551 CONST84_RETURN char *TclpGetCwd(Tcl_Interp *interp, Tcl_DString *cwdPtr) 552} 553declare 142 generic { 554 int TclSetByteCodeFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr, 555 CompileHookProc *hookProc, ClientData clientData) 556} 557declare 143 generic { 558 int TclAddLiteralObj(struct CompileEnv *envPtr, Tcl_Obj *objPtr, 559 LiteralEntry **litPtrPtr) 560} 561declare 144 generic { 562 void TclHideLiteral(Tcl_Interp *interp, struct CompileEnv *envPtr, 563 int index) 564} 565declare 145 generic { 566 struct AuxDataType *TclGetAuxDataType(char *typeName) 567} 568 569declare 146 generic { 570 TclHandle TclHandleCreate(VOID *ptr) 571} 572 573declare 147 generic { 574 void TclHandleFree(TclHandle handle) 575} 576 577declare 148 generic { 578 TclHandle TclHandlePreserve(TclHandle handle) 579} 580 581declare 149 generic { 582 void TclHandleRelease(TclHandle handle) 583} 584 585# Added for Tcl 8.2 586 587declare 150 generic { 588 int TclRegAbout(Tcl_Interp *interp, Tcl_RegExp re) 589} 590declare 151 generic { 591 void TclRegExpRangeUniChar(Tcl_RegExp re, int index, int *startPtr, 592 int *endPtr) 593} 594 595declare 152 generic { 596 void TclSetLibraryPath(Tcl_Obj *pathPtr) 597} 598declare 153 generic { 599 Tcl_Obj *TclGetLibraryPath(void) 600} 601 602# moved to tclTest.c (static) in 8.3.2/8.4a2 603#declare 154 generic { 604# int TclTestChannelCmd(ClientData clientData, 605# Tcl_Interp *interp, int argc, char **argv) 606#} 607#declare 155 generic { 608# int TclTestChannelEventCmd(ClientData clientData, 609# Tcl_Interp *interp, int argc, char **argv) 610#} 611 612declare 156 generic { 613 void TclRegError (Tcl_Interp *interp, CONST char *msg, 614 int status) 615} 616declare 157 generic { 617 Var * TclVarTraceExists (Tcl_Interp *interp, CONST char *varName) 618} 619declare 158 generic { 620 void TclSetStartupScriptFileName(CONST char *filename) 621} 622declare 159 generic { 623 CONST84_RETURN char *TclGetStartupScriptFileName(void) 624} 625#declare 160 generic { 626# int TclpMatchFilesTypes(Tcl_Interp *interp, char *separators, 627# Tcl_DString *dirPtr, char *pattern, char *tail, GlobTypeData *types) 628#} 629 630# new in 8.3.2/8.4a2 631declare 161 generic { 632 int TclChannelTransform(Tcl_Interp *interp, Tcl_Channel chan, 633 Tcl_Obj *cmdObjPtr) 634} 635declare 162 generic { 636 void TclChannelEventScriptInvoker(ClientData clientData, int flags) 637} 638 639# ALERT: The result of 'TclGetInstructionTable' is actually an 640# "InstructionDesc*" but we do not want to describe this structure in 641# "tclInt.h". It is described in "tclCompile.h". Use a cast to the 642# correct type when calling this procedure. 643 644declare 163 generic { 645 void * TclGetInstructionTable (void) 646} 647 648# ALERT: The argument of 'TclExpandCodeArray' is actually a 649# "CompileEnv*" but we do not want to describe this structure in 650# "tclInt.h". It is described in "tclCompile.h". 651 652declare 164 generic { 653 void TclExpandCodeArray (void *envPtr) 654} 655 656# These functions are vfs aware, but are generally only useful internally. 657declare 165 generic { 658 void TclpSetInitialEncodings(void) 659} 660 661# New function due to TIP #33 662declare 166 generic { 663 int TclListObjSetElement(Tcl_Interp *interp, Tcl_Obj *listPtr, 664 int index, Tcl_Obj *valuePtr) 665} 666 667# VFS-aware versions of Tcl*StartupScriptFileName (158 and 159 above) 668declare 167 generic { 669 void TclSetStartupScriptPath(Tcl_Obj *pathPtr) 670} 671declare 168 generic { 672 Tcl_Obj *TclGetStartupScriptPath(void) 673} 674# variant of Tcl_UtfNCmp that takes n as bytes, not chars 675declare 169 generic { 676 int TclpUtfNcmp2(CONST char *s1, CONST char *s2, unsigned long n) 677} 678declare 170 generic { 679 int TclCheckInterpTraces (Tcl_Interp *interp, CONST char *command, int numChars, \ 680 Command *cmdPtr, int result, int traceFlags, int objc, \ 681 Tcl_Obj *CONST objv[]) 682} 683declare 171 generic { 684 int TclCheckExecutionTraces (Tcl_Interp *interp, CONST char *command, int numChars, \ 685 Command *cmdPtr, int result, int traceFlags, int objc, \ 686 Tcl_Obj *CONST objv[]) 687} 688 689declare 172 generic { 690 int TclInThreadExit(void) 691} 692 693# added for 8.4.2 694 695declare 173 generic { 696 int TclUniCharMatch (CONST Tcl_UniChar *string, int strLen, \ 697 CONST Tcl_UniChar *pattern, int ptnLen, int nocase) 698} 699 700# TclpGmtime and TclpLocaltime promoted to the generic interface from unix 701 702declare 182 generic { 703 struct tm *TclpLocaltime(TclpTime_t_CONST clock) 704} 705declare 183 generic { 706 struct tm *TclpGmtime(TclpTime_t_CONST clock) 707} 708 709declare 199 generic { 710 int TclMatchIsTrivial(CONST char *pattern) 711} 712 713############################################################################## 714 715# Define the platform specific internal Tcl interface. These functions are 716# only available on the designated platform. 717 718interface tclIntPlat 719 720######################## 721# Mac specific internals 722 723declare 0 mac { 724 VOID * TclpSysAlloc(long size, int isBin) 725} 726declare 1 mac { 727 void TclpSysFree(VOID *ptr) 728} 729declare 2 mac { 730 VOID * TclpSysRealloc(VOID *cp, unsigned int size) 731} 732declare 3 mac { 733 void TclpExit(int status) 734} 735 736# Prototypes for functions found in the tclMacUtil.c compatability library. 737 738declare 4 mac { 739 int FSpGetDefaultDir(FSSpecPtr theSpec) 740} 741declare 5 mac { 742 int FSpSetDefaultDir(FSSpecPtr theSpec) 743} 744declare 6 mac { 745 OSErr FSpFindFolder(short vRefNum, OSType folderType, 746 Boolean createFolder, FSSpec *spec) 747} 748declare 7 mac { 749 void GetGlobalMouseTcl(Point *mouse) 750} 751 752# The following routines are utility functions in Tcl. They are exported 753# here because they are needed in Tk. They are not officially supported, 754# however. The first set are from the MoreFiles package. 755 756declare 8 mac { 757 pascal OSErr FSpGetDirectoryIDTcl(CONST FSSpec *spec, long *theDirID, 758 Boolean *isDirectory) 759} 760declare 9 mac { 761 pascal short FSpOpenResFileCompatTcl(CONST FSSpec *spec, 762 SignedByte permission) 763} 764declare 10 mac { 765 pascal void FSpCreateResFileCompatTcl(CONST FSSpec *spec, OSType creator, 766 OSType fileType, ScriptCode scriptTag) 767} 768 769# Like the MoreFiles routines these fix problems in the standard 770# Mac calls. These routines are from tclMacUtils.h. 771 772declare 11 mac { 773 int FSpLocationFromPath(int length, CONST char *path, FSSpecPtr theSpec) 774} 775declare 12 mac { 776 OSErr FSpPathFromLocation(FSSpecPtr theSpec, int *length, 777 Handle *fullPath) 778} 779 780# Prototypes of Mac only internal functions. 781 782declare 13 mac { 783 void TclMacExitHandler(void) 784} 785declare 14 mac { 786 void TclMacInitExitToShell(int usePatch) 787} 788declare 15 mac { 789 OSErr TclMacInstallExitToShellPatch(ExitToShellProcPtr newProc) 790} 791declare 16 mac { 792 int TclMacOSErrorToPosixError(int error) 793} 794declare 17 mac { 795 void TclMacRemoveTimer(void *timerToken) 796} 797declare 18 mac { 798 void * TclMacStartTimer(long ms) 799} 800declare 19 mac { 801 int TclMacTimerExpired(void *timerToken) 802} 803declare 20 mac { 804 int TclMacRegisterResourceFork(short fileRef, Tcl_Obj *tokenPtr, 805 int insert) 806} 807declare 21 mac { 808 short TclMacUnRegisterResourceFork(char *tokenPtr, Tcl_Obj *resultPtr) 809} 810declare 22 mac { 811 int TclMacCreateEnv(void) 812} 813declare 23 mac { 814 FILE * TclMacFOpenHack(CONST char *path, CONST char *mode) 815} 816# Replaced in 8.1 by TclpReadLink: 817# declare 24 mac { 818# int TclMacReadlink(char *path, char *buf, int size) 819# } 820declare 24 mac { 821 char * TclpGetTZName(int isdst) 822} 823declare 25 mac { 824 int TclMacChmod(CONST char *path, int mode) 825} 826# version of FSpLocationFromPath that doesn't resolve the last path component 827declare 26 mac { 828 int FSpLLocationFromPath(int length, CONST char *path, FSSpecPtr theSpec) 829} 830 831############################ 832# Windows specific internals 833 834declare 0 win { 835 void TclWinConvertError(DWORD errCode) 836} 837declare 1 win { 838 void TclWinConvertWSAError(DWORD errCode) 839} 840declare 2 win { 841 struct servent * TclWinGetServByName(CONST char *nm, 842 CONST char *proto) 843} 844declare 3 win { 845 int TclWinGetSockOpt(SOCKET s, int level, int optname, 846 char FAR * optval, int FAR *optlen) 847} 848declare 4 win { 849 HINSTANCE TclWinGetTclInstance(void) 850} 851# Removed in 8.1: 852# declare 5 win { 853# HINSTANCE TclWinLoadLibrary(char *name) 854# } 855declare 6 win { 856 u_short TclWinNToHS(u_short ns) 857} 858declare 7 win { 859 int TclWinSetSockOpt(SOCKET s, int level, int optname, 860 CONST char FAR * optval, int optlen) 861} 862declare 8 win { 863 unsigned long TclpGetPid(Tcl_Pid pid) 864} 865declare 9 win { 866 int TclWinGetPlatformId(void) 867} 868# Removed in 8.3.1 (for Win32s only) 869#declare 10 win { 870# int TclWinSynchSpawn(void *args, int type, void **trans, Tcl_Pid *pidPtr) 871#} 872 873# Pipe channel functions 874 875declare 11 win { 876 void TclGetAndDetachPids(Tcl_Interp *interp, Tcl_Channel chan) 877} 878declare 12 win { 879 int TclpCloseFile(TclFile file) 880} 881declare 13 win { 882 Tcl_Channel TclpCreateCommandChannel(TclFile readFile, 883 TclFile writeFile, TclFile errorFile, int numPids, Tcl_Pid *pidPtr) 884} 885declare 14 win { 886 int TclpCreatePipe(TclFile *readPipe, TclFile *writePipe) 887} 888declare 15 win { 889 int TclpCreateProcess(Tcl_Interp *interp, int argc, CONST char **argv, 890 TclFile inputFile, TclFile outputFile, TclFile errorFile, 891 Tcl_Pid *pidPtr) 892} 893# Signature changed in 8.1: 894# declare 16 win { 895# TclFile TclpCreateTempFile(char *contents, Tcl_DString *namePtr) 896# } 897# declare 17 win { 898# char * TclpGetTZName(void) 899# } 900declare 18 win { 901 TclFile TclpMakeFile(Tcl_Channel channel, int direction) 902} 903declare 19 win { 904 TclFile TclpOpenFile(CONST char *fname, int mode) 905} 906declare 20 win { 907 void TclWinAddProcess(HANDLE hProcess, DWORD id) 908} 909 910# removed permanently for 8.4 911#declare 21 win { 912# void TclpAsyncMark(Tcl_AsyncHandler async) 913#} 914 915# Added in 8.1: 916declare 22 win { 917 TclFile TclpCreateTempFile(CONST char *contents) 918} 919declare 23 win { 920 char * TclpGetTZName(int isdst) 921} 922declare 24 win { 923 char * TclWinNoBackslash(char *path) 924} 925declare 25 win { 926 TclPlatformType *TclWinGetPlatform(void) 927} 928declare 26 win { 929 void TclWinSetInterfaces(int wide) 930} 931 932# Added in Tcl 8.3.3 / 8.4 933 934declare 27 win { 935 void TclWinFlushDirtyChannels (void) 936} 937 938# Added in 8.4.2 939 940declare 28 win { 941 void TclWinResetInterfaces(void) 942} 943 944declare 29 win { 945 int TclWinCPUID( unsigned int index, unsigned int *regs ) 946} 947 948######################### 949# Unix specific internals 950 951# Pipe channel functions 952 953declare 0 unix { 954 void TclGetAndDetachPids(Tcl_Interp *interp, Tcl_Channel chan) 955} 956declare 1 unix { 957 int TclpCloseFile(TclFile file) 958} 959declare 2 unix { 960 Tcl_Channel TclpCreateCommandChannel(TclFile readFile, 961 TclFile writeFile, TclFile errorFile, int numPids, Tcl_Pid *pidPtr) 962} 963declare 3 unix { 964 int TclpCreatePipe(TclFile *readPipe, TclFile *writePipe) 965} 966declare 4 unix { 967 int TclpCreateProcess(Tcl_Interp *interp, int argc, CONST char **argv, 968 TclFile inputFile, TclFile outputFile, TclFile errorFile, 969 Tcl_Pid *pidPtr) 970} 971# Signature changed in 8.1: 972# declare 5 unix { 973# TclFile TclpCreateTempFile(char *contents, Tcl_DString *namePtr) 974# } 975declare 6 unix { 976 TclFile TclpMakeFile(Tcl_Channel channel, int direction) 977} 978declare 7 unix { 979 TclFile TclpOpenFile(CONST char *fname, int mode) 980} 981declare 8 unix { 982 int TclUnixWaitForFile(int fd, int mask, int timeout) 983} 984 985# Added in 8.1: 986 987declare 9 unix { 988 TclFile TclpCreateTempFile(CONST char *contents) 989} 990 991# Added in 8.4: 992 993declare 10 unix { 994 Tcl_DirEntry * TclpReaddir(DIR * dir) 995} 996 997# Slots 11 and 12 are forwarders for functions that were promoted to 998# generic Stubs 999 1000declare 11 unix { 1001 struct tm * TclpLocaltime_unix(TclpTime_t_CONST clock) 1002} 1003 1004declare 12 unix { 1005 struct tm * TclpGmtime_unix(TclpTime_t_CONST clock) 1006} 1007 1008declare 13 unix { 1009 char * TclpInetNtoa(struct in_addr addr) 1010} 1011 1012