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# Copyright (c) 2007 Daniel A. Steffen <das@users.sourceforge.net> 12# 13# See the file "license.terms" for information on usage and redistribution 14# of this file, and for a DISCLAIMER OF ALL WARRANTIES. 15# 16# RCS: @(#) $Id: tclInt.decls,v 1.121.2.4 2010/02/07 22:16:54 nijtmans Exp $ 17 18library tcl 19 20# Define the unsupported generic interfaces. 21 22interface tclInt 23 24# Declare each of the functions in the unsupported internal Tcl 25# interface. These interfaces are allowed to changed between versions. 26# Use at your own risk. Note that the position of functions should not 27# be changed between versions to avoid gratuitous incompatibilities. 28 29# Replaced by Tcl_FSAccess in 8.4: 30#declare 0 generic { 31# int TclAccess(CONST char *path, int mode) 32#} 33#declare 1 generic { 34# int TclAccessDeleteProc(TclAccessProc_ *proc) 35#} 36#declare 2 generic { 37# int TclAccessInsertProc(TclAccessProc_ *proc) 38#} 39declare 3 generic { 40 void TclAllocateFreeObjects(void) 41} 42# Replaced by TclpChdir in 8.1: 43# declare 4 generic { 44# int TclChdir(Tcl_Interp *interp, char *dirName) 45# } 46declare 5 generic { 47 int TclCleanupChildren(Tcl_Interp *interp, int numPids, Tcl_Pid *pidPtr, 48 Tcl_Channel errorChan) 49} 50declare 6 generic { 51 void TclCleanupCommand(Command *cmdPtr) 52} 53declare 7 generic { 54 int TclCopyAndCollapse(int count, CONST char *src, char *dst) 55} 56declare 8 generic { 57 int TclCopyChannel(Tcl_Interp *interp, Tcl_Channel inChan, 58 Tcl_Channel outChan, int toRead, Tcl_Obj *cmdPtr) 59} 60 61# TclCreatePipeline unofficially exported for use by BLT. 62 63declare 9 generic { 64 int TclCreatePipeline(Tcl_Interp *interp, int argc, CONST char **argv, 65 Tcl_Pid **pidArrayPtr, TclFile *inPipePtr, TclFile *outPipePtr, 66 TclFile *errFilePtr) 67} 68declare 10 generic { 69 int TclCreateProc(Tcl_Interp *interp, Namespace *nsPtr, 70 CONST char *procName, 71 Tcl_Obj *argsPtr, Tcl_Obj *bodyPtr, Proc **procPtrPtr) 72} 73declare 11 generic { 74 void TclDeleteCompiledLocalVars(Interp *iPtr, CallFrame *framePtr) 75} 76declare 12 generic { 77 void TclDeleteVars(Interp *iPtr, TclVarHashTable *tablePtr) 78} 79# Removed in 8.5 80#declare 13 generic { 81# int TclDoGlob(Tcl_Interp *interp, char *separators, 82# Tcl_DString *headPtr, char *tail, Tcl_GlobTypeData *types) 83#} 84declare 14 generic { 85 void TclDumpMemoryInfo(FILE *outFile) 86} 87# Removed in 8.1: 88# declare 15 generic { 89# void TclExpandParseValue(ParseValue *pvPtr, int needed) 90# } 91declare 16 generic { 92 void TclExprFloatError(Tcl_Interp *interp, double value) 93} 94# Removed in 8.4 95#declare 17 generic { 96# int TclFileAttrsCmd(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) 97#} 98#declare 18 generic { 99# int TclFileCopyCmd(Tcl_Interp *interp, int argc, char **argv) 100#} 101#declare 19 generic { 102# int TclFileDeleteCmd(Tcl_Interp *interp, int argc, char **argv) 103#} 104#declare 20 generic { 105# int TclFileMakeDirsCmd(Tcl_Interp *interp, int argc, char **argv) 106#} 107#declare 21 generic { 108# int TclFileRenameCmd(Tcl_Interp *interp, int argc, char **argv) 109#} 110declare 22 generic { 111 int TclFindElement(Tcl_Interp *interp, CONST char *listStr, 112 int listLength, CONST char **elementPtr, CONST char **nextPtr, 113 int *sizePtr, int *bracePtr) 114} 115declare 23 generic { 116 Proc *TclFindProc(Interp *iPtr, CONST char *procName) 117} 118# Replaced with macro (see tclInt.h) in Tcl 8.5 119#declare 24 generic { 120# int TclFormatInt(char *buffer, long n) 121#} 122declare 25 generic { 123 void TclFreePackageInfo(Interp *iPtr) 124} 125# Removed in 8.1: 126# declare 26 generic { 127# char *TclGetCwd(Tcl_Interp *interp) 128# } 129# Removed in 8.5 130#declare 27 generic { 131# int TclGetDate(char *p, unsigned long now, long zone, 132# unsigned long *timePtr) 133#} 134declare 28 generic { 135 Tcl_Channel TclpGetDefaultStdChannel(int type) 136} 137# Removed in 8.4b2: 138#declare 29 generic { 139# Tcl_Obj *TclGetElementOfIndexedArray(Tcl_Interp *interp, 140# int localIndex, Tcl_Obj *elemPtr, int flags) 141#} 142# Replaced by char *TclGetEnv(CONST char *name, Tcl_DString *valuePtr) in 8.1: 143# declare 30 generic { 144# char *TclGetEnv(CONST char *name) 145# } 146declare 31 generic { 147 CONST char *TclGetExtension(CONST char *name) 148} 149declare 32 generic { 150 int TclGetFrame(Tcl_Interp *interp, CONST char *str, 151 CallFrame **framePtrPtr) 152} 153# Removed in Tcl 8.5 154#declare 33 generic { 155# TclCmdProcType TclGetInterpProc(void) 156#} 157declare 34 generic { 158 int TclGetIntForIndex(Tcl_Interp *interp, Tcl_Obj *objPtr, 159 int endValue, int *indexPtr) 160} 161# Removed in 8.4b2: 162#declare 35 generic { 163# Tcl_Obj *TclGetIndexedScalar(Tcl_Interp *interp, int localIndex, 164# int flags) 165#} 166declare 36 generic { 167 int TclGetLong(Tcl_Interp *interp, CONST char *str, long *longPtr) 168} 169declare 37 generic { 170 int TclGetLoadedPackages(Tcl_Interp *interp, char *targetName) 171} 172declare 38 generic { 173 int TclGetNamespaceForQualName(Tcl_Interp *interp, CONST char *qualName, 174 Namespace *cxtNsPtr, int flags, Namespace **nsPtrPtr, 175 Namespace **altNsPtrPtr, Namespace **actualCxtPtrPtr, 176 CONST char **simpleNamePtr) 177} 178declare 39 generic { 179 TclObjCmdProcType TclGetObjInterpProc(void) 180} 181declare 40 generic { 182 int TclGetOpenMode(Tcl_Interp *interp, CONST char *str, int *seekFlagPtr) 183} 184declare 41 generic { 185 Tcl_Command TclGetOriginalCommand(Tcl_Command command) 186} 187declare 42 generic { 188 char *TclpGetUserHome(CONST char *name, Tcl_DString *bufferPtr) 189} 190# Removed in Tcl 8.5a2 191#declare 43 generic { 192# int TclGlobalInvoke(Tcl_Interp *interp, int argc, CONST84 char **argv, 193# int flags) 194#} 195declare 44 generic { 196 int TclGuessPackageName(CONST char *fileName, Tcl_DString *bufPtr) 197} 198declare 45 generic { 199 int TclHideUnsafeCommands(Tcl_Interp *interp) 200} 201declare 46 generic { 202 int TclInExit(void) 203} 204# Removed in 8.4b2: 205#declare 47 generic { 206# Tcl_Obj *TclIncrElementOfIndexedArray(Tcl_Interp *interp, 207# int localIndex, Tcl_Obj *elemPtr, long incrAmount) 208#} 209# Removed in 8.4b2: 210#declare 48 generic { 211# Tcl_Obj *TclIncrIndexedScalar(Tcl_Interp *interp, int localIndex, 212# long incrAmount) 213#} 214#declare 49 generic { 215# Tcl_Obj *TclIncrVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr, 216# Tcl_Obj *part2Ptr, long incrAmount, int part1NotParsed) 217#} 218declare 50 generic { 219 void TclInitCompiledLocals(Tcl_Interp *interp, CallFrame *framePtr, 220 Namespace *nsPtr) 221} 222declare 51 generic { 223 int TclInterpInit(Tcl_Interp *interp) 224} 225# Removed in Tcl 8.5a2 226#declare 52 generic { 227# int TclInvoke(Tcl_Interp *interp, int argc, CONST84 char **argv, 228# int flags) 229#} 230declare 53 generic { 231 int TclInvokeObjectCommand(ClientData clientData, Tcl_Interp *interp, 232 int argc, CONST84 char **argv) 233} 234declare 54 generic { 235 int TclInvokeStringCommand(ClientData clientData, Tcl_Interp *interp, 236 int objc, Tcl_Obj *CONST objv[]) 237} 238declare 55 generic { 239 Proc *TclIsProc(Command *cmdPtr) 240} 241# Replaced with TclpLoadFile in 8.1: 242# declare 56 generic { 243# int TclLoadFile(Tcl_Interp *interp, char *fileName, char *sym1, 244# char *sym2, Tcl_PackageInitProc **proc1Ptr, 245# Tcl_PackageInitProc **proc2Ptr) 246# } 247# Signature changed to take a length in 8.1: 248# declare 57 generic { 249# int TclLooksLikeInt(char *p) 250# } 251declare 58 generic { 252 Var *TclLookupVar(Tcl_Interp *interp, CONST char *part1, CONST char *part2, 253 int flags, CONST char *msg, int createPart1, int createPart2, 254 Var **arrayPtrPtr) 255} 256# Replaced by Tcl_FSMatchInDirectory in 8.4 257#declare 59 generic { 258# int TclpMatchFiles(Tcl_Interp *interp, char *separators, 259# Tcl_DString *dirPtr, char *pattern, char *tail) 260#} 261declare 60 generic { 262 int TclNeedSpace(CONST char *start, CONST char *end) 263} 264declare 61 generic { 265 Tcl_Obj *TclNewProcBodyObj(Proc *procPtr) 266} 267declare 62 generic { 268 int TclObjCommandComplete(Tcl_Obj *cmdPtr) 269} 270declare 63 generic { 271 int TclObjInterpProc(ClientData clientData, Tcl_Interp *interp, 272 int objc, Tcl_Obj *CONST objv[]) 273} 274declare 64 generic { 275 int TclObjInvoke(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], 276 int flags) 277} 278# Removed in Tcl 8.5a2 279#declare 65 generic { 280# int TclObjInvokeGlobal(Tcl_Interp *interp, int objc, 281# Tcl_Obj *CONST objv[], int flags) 282#} 283#declare 66 generic { 284# int TclOpenFileChannelDeleteProc(TclOpenFileChannelProc_ *proc) 285#} 286#declare 67 generic { 287# int TclOpenFileChannelInsertProc(TclOpenFileChannelProc_ *proc) 288#} 289# Replaced by Tcl_FSAccess in 8.4: 290#declare 68 generic { 291# int TclpAccess(CONST char *path, int mode) 292#} 293declare 69 generic { 294 char *TclpAlloc(unsigned int size) 295} 296#declare 70 generic { 297# int TclpCopyFile(CONST char *source, CONST char *dest) 298#} 299#declare 71 generic { 300# int TclpCopyDirectory(CONST char *source, CONST char *dest, 301# Tcl_DString *errorPtr) 302#} 303#declare 72 generic { 304# int TclpCreateDirectory(CONST char *path) 305#} 306#declare 73 generic { 307# int TclpDeleteFile(CONST char *path) 308#} 309declare 74 generic { 310 void TclpFree(char *ptr) 311} 312declare 75 generic { 313 unsigned long TclpGetClicks(void) 314} 315declare 76 generic { 316 unsigned long TclpGetSeconds(void) 317} 318 319# deprecated 320declare 77 generic { 321 void TclpGetTime(Tcl_Time *time) 322} 323declare 78 generic { 324 int TclpGetTimeZone(unsigned long time) 325} 326# Replaced by Tcl_FSListVolumes in 8.4: 327#declare 79 generic { 328# int TclpListVolumes(Tcl_Interp *interp) 329#} 330# Replaced by Tcl_FSOpenFileChannel in 8.4: 331#declare 80 generic { 332# Tcl_Channel TclpOpenFileChannel(Tcl_Interp *interp, char *fileName, 333# char *modeString, int permissions) 334#} 335declare 81 generic { 336 char *TclpRealloc(char *ptr, unsigned int size) 337} 338#declare 82 generic { 339# int TclpRemoveDirectory(CONST char *path, int recursive, 340# Tcl_DString *errorPtr) 341#} 342#declare 83 generic { 343# int TclpRenameFile(CONST char *source, CONST char *dest) 344#} 345# Removed in 8.1: 346# declare 84 generic { 347# int TclParseBraces(Tcl_Interp *interp, char *str, char **termPtr, 348# ParseValue *pvPtr) 349# } 350# declare 85 generic { 351# int TclParseNestedCmd(Tcl_Interp *interp, char *str, int flags, 352# char **termPtr, ParseValue *pvPtr) 353# } 354# declare 86 generic { 355# int TclParseQuotes(Tcl_Interp *interp, char *str, int termChar, 356# int flags, char **termPtr, ParseValue *pvPtr) 357# } 358# declare 87 generic { 359# void TclPlatformInit(Tcl_Interp *interp) 360# } 361declare 88 generic { 362 char *TclPrecTraceProc(ClientData clientData, Tcl_Interp *interp, 363 CONST char *name1, CONST char *name2, int flags) 364} 365declare 89 generic { 366 int TclPreventAliasLoop(Tcl_Interp *interp, Tcl_Interp *cmdInterp, 367 Tcl_Command cmd) 368} 369# Removed in 8.1 (only available if compiled with TCL_COMPILE_DEBUG): 370# declare 90 generic { 371# void TclPrintByteCodeObj(Tcl_Interp *interp, Tcl_Obj *objPtr) 372# } 373declare 91 generic { 374 void TclProcCleanupProc(Proc *procPtr) 375} 376declare 92 generic { 377 int TclProcCompileProc(Tcl_Interp *interp, Proc *procPtr, 378 Tcl_Obj *bodyPtr, Namespace *nsPtr, CONST char *description, 379 CONST char *procName) 380} 381declare 93 generic { 382 void TclProcDeleteProc(ClientData clientData) 383} 384# Removed in Tcl 8.5: 385#declare 94 generic { 386# int TclProcInterpProc(ClientData clientData, Tcl_Interp *interp, 387# int argc, CONST84 char **argv) 388#} 389# Replaced by Tcl_FSStat in 8.4: 390#declare 95 generic { 391# int TclpStat(CONST char *path, Tcl_StatBuf *buf) 392#} 393declare 96 generic { 394 int TclRenameCommand(Tcl_Interp *interp, CONST char *oldName, 395 CONST char *newName) 396} 397declare 97 generic { 398 void TclResetShadowedCmdRefs(Tcl_Interp *interp, Command *newCmdPtr) 399} 400declare 98 generic { 401 int TclServiceIdle(void) 402} 403# Removed in 8.4b2: 404#declare 99 generic { 405# Tcl_Obj *TclSetElementOfIndexedArray(Tcl_Interp *interp, int localIndex, 406# Tcl_Obj *elemPtr, Tcl_Obj *objPtr, int flags) 407#} 408# Removed in 8.4b2: 409#declare 100 generic { 410# Tcl_Obj *TclSetIndexedScalar(Tcl_Interp *interp, int localIndex, 411# Tcl_Obj *objPtr, int flags) 412#} 413declare 101 generic { 414 char *TclSetPreInitScript(char *string) 415} 416declare 102 generic { 417 void TclSetupEnv(Tcl_Interp *interp) 418} 419declare 103 generic { 420 int TclSockGetPort(Tcl_Interp *interp, CONST char *str, CONST char *proto, 421 int *portPtr) 422} 423declare 104 generic { 424 int TclSockMinimumBuffers(int sock, int size) 425} 426# Replaced by Tcl_FSStat in 8.4: 427#declare 105 generic { 428# int TclStat(CONST char *path, Tcl_StatBuf *buf) 429#} 430#declare 106 generic { 431# int TclStatDeleteProc(TclStatProc_ *proc) 432#} 433#declare 107 generic { 434# int TclStatInsertProc(TclStatProc_ *proc) 435#} 436declare 108 generic { 437 void TclTeardownNamespace(Namespace *nsPtr) 438} 439declare 109 generic { 440 int TclUpdateReturnInfo(Interp *iPtr) 441} 442# Removed in 8.1: 443# declare 110 generic { 444# char *TclWordEnd(char *start, char *lastChar, int nested, int *semiPtr) 445# } 446 447# Procedures used in conjunction with Tcl namespaces. They are 448# defined here instead of in tcl.decls since they are not stable yet. 449 450declare 111 generic { 451 void Tcl_AddInterpResolvers(Tcl_Interp *interp, CONST char *name, 452 Tcl_ResolveCmdProc *cmdProc, Tcl_ResolveVarProc *varProc, 453 Tcl_ResolveCompiledVarProc *compiledVarProc) 454} 455declare 112 generic { 456 int Tcl_AppendExportList(Tcl_Interp *interp, Tcl_Namespace *nsPtr, 457 Tcl_Obj *objPtr) 458} 459declare 113 generic { 460 Tcl_Namespace *Tcl_CreateNamespace(Tcl_Interp *interp, CONST char *name, 461 ClientData clientData, Tcl_NamespaceDeleteProc *deleteProc) 462} 463declare 114 generic { 464 void Tcl_DeleteNamespace(Tcl_Namespace *nsPtr) 465} 466declare 115 generic { 467 int Tcl_Export(Tcl_Interp *interp, Tcl_Namespace *nsPtr, 468 CONST char *pattern, int resetListFirst) 469} 470declare 116 generic { 471 Tcl_Command Tcl_FindCommand(Tcl_Interp *interp, CONST char *name, 472 Tcl_Namespace *contextNsPtr, int flags) 473} 474declare 117 generic { 475 Tcl_Namespace *Tcl_FindNamespace(Tcl_Interp *interp, CONST char *name, 476 Tcl_Namespace *contextNsPtr, int flags) 477} 478declare 118 generic { 479 int Tcl_GetInterpResolvers(Tcl_Interp *interp, CONST char *name, 480 Tcl_ResolverInfo *resInfo) 481} 482declare 119 generic { 483 int Tcl_GetNamespaceResolvers(Tcl_Namespace *namespacePtr, 484 Tcl_ResolverInfo *resInfo) 485} 486declare 120 generic { 487 Tcl_Var Tcl_FindNamespaceVar(Tcl_Interp *interp, CONST char *name, 488 Tcl_Namespace *contextNsPtr, int flags) 489} 490declare 121 generic { 491 int Tcl_ForgetImport(Tcl_Interp *interp, Tcl_Namespace *nsPtr, 492 CONST char *pattern) 493} 494declare 122 generic { 495 Tcl_Command Tcl_GetCommandFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr) 496} 497declare 123 generic { 498 void Tcl_GetCommandFullName(Tcl_Interp *interp, Tcl_Command command, 499 Tcl_Obj *objPtr) 500} 501declare 124 generic { 502 Tcl_Namespace *Tcl_GetCurrentNamespace(Tcl_Interp *interp) 503} 504declare 125 generic { 505 Tcl_Namespace *Tcl_GetGlobalNamespace(Tcl_Interp *interp) 506} 507declare 126 generic { 508 void Tcl_GetVariableFullName(Tcl_Interp *interp, Tcl_Var variable, 509 Tcl_Obj *objPtr) 510} 511declare 127 generic { 512 int Tcl_Import(Tcl_Interp *interp, Tcl_Namespace *nsPtr, 513 CONST char *pattern, int allowOverwrite) 514} 515declare 128 generic { 516 void Tcl_PopCallFrame(Tcl_Interp *interp) 517} 518declare 129 generic { 519 int Tcl_PushCallFrame(Tcl_Interp *interp, Tcl_CallFrame *framePtr, 520 Tcl_Namespace *nsPtr, int isProcCallFrame) 521} 522declare 130 generic { 523 int Tcl_RemoveInterpResolvers(Tcl_Interp *interp, CONST char *name) 524} 525declare 131 generic { 526 void Tcl_SetNamespaceResolvers(Tcl_Namespace *namespacePtr, 527 Tcl_ResolveCmdProc *cmdProc, Tcl_ResolveVarProc *varProc, 528 Tcl_ResolveCompiledVarProc *compiledVarProc) 529} 530declare 132 generic { 531 int TclpHasSockets(Tcl_Interp *interp) 532} 533declare 133 generic { 534 struct tm *TclpGetDate(CONST time_t *time, int useGMT) 535} 536# Removed in 8.5 537#declare 134 generic { 538# size_t TclpStrftime(char *s, size_t maxsize, CONST char *format, 539# CONST struct tm *t, int useGMT) 540#} 541#declare 135 generic { 542# int TclpCheckStackSpace(void) 543#} 544 545# Added in 8.1: 546 547#declare 137 generic { 548# int TclpChdir(CONST char *dirName) 549#} 550declare 138 generic { 551 CONST84_RETURN char *TclGetEnv(CONST char *name, Tcl_DString *valuePtr) 552} 553#declare 139 generic { 554# int TclpLoadFile(Tcl_Interp *interp, char *fileName, char *sym1, 555# char *sym2, Tcl_PackageInitProc **proc1Ptr, 556# Tcl_PackageInitProc **proc2Ptr, ClientData *clientDataPtr) 557#} 558#declare 140 generic { 559# int TclLooksLikeInt(CONST char *bytes, int length) 560#} 561# This is used by TclX, but should otherwise be considered private 562declare 141 generic { 563 CONST84_RETURN char *TclpGetCwd(Tcl_Interp *interp, Tcl_DString *cwdPtr) 564} 565declare 142 generic { 566 int TclSetByteCodeFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr, 567 CompileHookProc *hookProc, ClientData clientData) 568} 569declare 143 generic { 570 int TclAddLiteralObj(struct CompileEnv *envPtr, Tcl_Obj *objPtr, 571 LiteralEntry **litPtrPtr) 572} 573declare 144 generic { 574 void TclHideLiteral(Tcl_Interp *interp, struct CompileEnv *envPtr, 575 int index) 576} 577declare 145 generic { 578 struct AuxDataType *TclGetAuxDataType(char *typeName) 579} 580declare 146 generic { 581 TclHandle TclHandleCreate(VOID *ptr) 582} 583declare 147 generic { 584 void TclHandleFree(TclHandle handle) 585} 586declare 148 generic { 587 TclHandle TclHandlePreserve(TclHandle handle) 588} 589declare 149 generic { 590 void TclHandleRelease(TclHandle handle) 591} 592 593# Added for Tcl 8.2 594 595declare 150 generic { 596 int TclRegAbout(Tcl_Interp *interp, Tcl_RegExp re) 597} 598declare 151 generic { 599 void TclRegExpRangeUniChar(Tcl_RegExp re, int index, int *startPtr, 600 int *endPtr) 601} 602declare 152 generic { 603 void TclSetLibraryPath(Tcl_Obj *pathPtr) 604} 605declare 153 generic { 606 Tcl_Obj *TclGetLibraryPath(void) 607} 608 609# moved to tclTest.c (static) in 8.3.2/8.4a2 610#declare 154 generic { 611# int TclTestChannelCmd(ClientData clientData, 612# Tcl_Interp *interp, int argc, char **argv) 613#} 614#declare 155 generic { 615# int TclTestChannelEventCmd(ClientData clientData, 616# Tcl_Interp *interp, int argc, char **argv) 617#} 618 619declare 156 generic { 620 void TclRegError(Tcl_Interp *interp, CONST char *msg, 621 int status) 622} 623declare 157 generic { 624 Var *TclVarTraceExists(Tcl_Interp *interp, CONST char *varName) 625} 626declare 158 generic { 627 void TclSetStartupScriptFileName(CONST char *filename) 628} 629declare 159 generic { 630 CONST84_RETURN char *TclGetStartupScriptFileName(void) 631} 632#declare 160 generic { 633# int TclpMatchFilesTypes(Tcl_Interp *interp, char *separators, 634# Tcl_DString *dirPtr, char *pattern, char *tail, 635# GlobTypeData *types) 636#} 637 638# new in 8.3.2/8.4a2 639declare 161 generic { 640 int TclChannelTransform(Tcl_Interp *interp, Tcl_Channel chan, 641 Tcl_Obj *cmdObjPtr) 642} 643declare 162 generic { 644 void TclChannelEventScriptInvoker(ClientData clientData, int flags) 645} 646 647# ALERT: The result of 'TclGetInstructionTable' is actually a 648# "InstructionDesc*" but we do not want to describe this structure in 649# "tclInt.h". It is described in "tclCompile.h". Use a cast to the 650# correct type when calling this procedure. 651 652declare 163 generic { 653 void *TclGetInstructionTable(void) 654} 655 656# ALERT: The argument of 'TclExpandCodeArray' is actually a 657# "CompileEnv*" but we do not want to describe this structure in 658# "tclInt.h". It is described in "tclCompile.h". 659 660declare 164 generic { 661 void TclExpandCodeArray(void *envPtr) 662} 663 664# These functions are vfs aware, but are generally only useful internally. 665declare 165 generic { 666 void TclpSetInitialEncodings(void) 667} 668 669# New function due to TIP #33 670declare 166 generic { 671 int TclListObjSetElement(Tcl_Interp *interp, Tcl_Obj *listPtr, 672 int index, Tcl_Obj *valuePtr) 673} 674 675# VFS-aware versions of Tcl*StartupScriptFileName (158 and 159 above) 676declare 167 generic { 677 void TclSetStartupScriptPath(Tcl_Obj *pathPtr) 678} 679declare 168 generic { 680 Tcl_Obj *TclGetStartupScriptPath(void) 681} 682# variant of Tcl_UtfNCmp that takes n as bytes, not chars 683declare 169 generic { 684 int TclpUtfNcmp2(CONST char *s1, CONST char *s2, unsigned long n) 685} 686declare 170 generic { 687 int TclCheckInterpTraces(Tcl_Interp *interp, CONST char *command, 688 int numChars, Command *cmdPtr, int result, int traceFlags, 689 int objc, Tcl_Obj *CONST objv[]) 690} 691declare 171 generic { 692 int TclCheckExecutionTraces(Tcl_Interp *interp, CONST char *command, 693 int numChars, Command *cmdPtr, int result, int traceFlags, 694 int objc, Tcl_Obj *CONST objv[]) 695} 696declare 172 generic { 697 int TclInThreadExit(void) 698} 699 700# added for 8.4.2 701 702declare 173 generic { 703 int TclUniCharMatch(CONST Tcl_UniChar *string, int strLen, 704 CONST Tcl_UniChar *pattern, int ptnLen, int flags) 705} 706 707# added for 8.4.3 708 709#declare 174 generic { 710# Tcl_Obj *TclIncrWideVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr, 711# Tcl_Obj *part2Ptr, Tcl_WideInt wideIncrAmount, int part1NotParsed) 712#} 713 714# Factoring out of trace code 715 716declare 175 generic { 717 int TclCallVarTraces(Interp *iPtr, Var *arrayPtr, Var *varPtr, 718 CONST char *part1, CONST char *part2, int flags, int leaveErrMsg) 719} 720declare 176 generic { 721 void TclCleanupVar(Var *varPtr, Var *arrayPtr) 722} 723declare 177 generic { 724 void TclVarErrMsg(Tcl_Interp *interp, CONST char *part1, CONST char *part2, 725 CONST char *operation, CONST char *reason) 726} 727declare 178 generic { 728 void Tcl_SetStartupScript(Tcl_Obj *pathPtr, CONST char* encodingName) 729} 730declare 179 generic { 731 Tcl_Obj *Tcl_GetStartupScript(CONST char **encodingNamePtr) 732} 733 734# REMOVED 735# Allocate lists without copying arrays 736# declare 180 generic { 737# Tcl_Obj *TclNewListObjDirect(int objc, Tcl_Obj **objv) 738# } 739#declare 181 generic { 740# Tcl_Obj *TclDbNewListObjDirect(int objc, Tcl_Obj **objv, 741# CONST char *file, int line) 742#} 743 744# TclpGmtime and TclpLocaltime promoted to the generic interface from unix 745 746declare 182 generic { 747 struct tm *TclpLocaltime(CONST time_t *clock) 748} 749declare 183 generic { 750 struct tm *TclpGmtime(CONST time_t *clock) 751} 752 753# For the new "Thread Storage" subsystem. 754 755### REMOVED on grounds it should never have been exposed. All these 756### functions are now either static in tclThreadStorage.c or 757### MODULE_SCOPE. 758# declare 184 generic { 759# void TclThreadStorageLockInit(void) 760# } 761# declare 185 generic { 762# void TclThreadStorageLock(void) 763# } 764# declare 186 generic { 765# void TclThreadStorageUnlock(void) 766# } 767# declare 187 generic { 768# void TclThreadStoragePrint(FILE *outFile, int flags) 769# } 770# declare 188 generic { 771# Tcl_HashTable *TclThreadStorageGetHashTable(Tcl_ThreadId id) 772# } 773# declare 189 generic { 774# Tcl_HashTable *TclThreadStorageInit(Tcl_ThreadId id, void *reserved) 775# } 776# declare 190 generic { 777# void TclThreadStorageDataKeyInit(Tcl_ThreadDataKey *keyPtr) 778# } 779# declare 191 generic { 780# void *TclThreadStorageDataKeyGet(Tcl_ThreadDataKey *keyPtr) 781# } 782# declare 192 generic { 783# void TclThreadStorageDataKeySet(Tcl_ThreadDataKey *keyPtr, void *data) 784# } 785# declare 193 generic { 786# void TclFinalizeThreadStorageThread(Tcl_ThreadId id) 787# } 788# declare 194 generic { 789# void TclFinalizeThreadStorage(void) 790# } 791# declare 195 generic { 792# void TclFinalizeThreadStorageData(Tcl_ThreadDataKey *keyPtr) 793# } 794# declare 196 generic { 795# void TclFinalizeThreadStorageDataKey(Tcl_ThreadDataKey *keyPtr) 796# } 797 798# 799# Added in tcl8.5a5 for compiler/executor experimentation. 800# Disabled in Tcl 8.5.1; experiments terminated. :/ 801# 802#declare 197 generic { 803# int TclCompEvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr, 804# CONST CmdFrame *invoker, int word) 805#} 806declare 198 generic { 807 int TclObjGetFrame(Tcl_Interp *interp, Tcl_Obj *objPtr, 808 CallFrame **framePtrPtr) 809} 810 811#declare 199 generic { 812# int TclMatchIsTrivial(CONST char *pattern) 813#} 814 815# 200-208 exported for use by the test suite [Bug 1054748] 816declare 200 generic { 817 int TclpObjRemoveDirectory(Tcl_Obj *pathPtr, int recursive, 818 Tcl_Obj **errorPtr) 819} 820declare 201 generic { 821 int TclpObjCopyDirectory(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr, 822 Tcl_Obj **errorPtr) 823} 824declare 202 generic { 825 int TclpObjCreateDirectory(Tcl_Obj *pathPtr) 826} 827declare 203 generic { 828 int TclpObjDeleteFile(Tcl_Obj *pathPtr) 829} 830declare 204 generic { 831 int TclpObjCopyFile(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr) 832} 833declare 205 generic { 834 int TclpObjRenameFile(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr) 835} 836declare 206 generic { 837 int TclpObjStat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf) 838} 839declare 207 generic { 840 int TclpObjAccess(Tcl_Obj *pathPtr, int mode) 841} 842declare 208 generic { 843 Tcl_Channel TclpOpenFileChannel(Tcl_Interp *interp, 844 Tcl_Obj *pathPtr, int mode, int permissions) 845} 846# Made public by TIP 258 847#declare 209 generic { 848# Tcl_Obj *TclGetEncodingSearchPath(void) 849#} 850#declare 210 generic { 851# int TclSetEncodingSearchPath(Tcl_Obj *searchPath) 852#} 853#declare 211 generic { 854# CONST char *TclpGetEncodingNameFromEnvironment(Tcl_DString *bufPtr) 855#} 856declare 212 generic { 857 void TclpFindExecutable(CONST char *argv0) 858} 859declare 213 generic { 860 Tcl_Obj *TclGetObjNameOfExecutable(void) 861} 862declare 214 generic { 863 void TclSetObjNameOfExecutable(Tcl_Obj *name, Tcl_Encoding encoding) 864} 865declare 215 generic { 866 void *TclStackAlloc(Tcl_Interp *interp, int numBytes) 867} 868declare 216 generic { 869 void TclStackFree(Tcl_Interp *interp, void *freePtr) 870} 871declare 217 generic { 872 int TclPushStackFrame(Tcl_Interp *interp, Tcl_CallFrame **framePtrPtr, 873 Tcl_Namespace *namespacePtr, int isProcCallFrame) 874} 875declare 218 generic { 876 void TclPopStackFrame(Tcl_Interp *interp) 877} 878 879# for use in tclTest.c 880declare 224 generic { 881 TclPlatformType *TclGetPlatform(void) 882} 883 884# 885declare 225 generic { 886 Tcl_Obj *TclTraceDictPath(Tcl_Interp *interp, Tcl_Obj *rootPtr, 887 int keyc, Tcl_Obj *CONST keyv[], int flags) 888} 889declare 226 generic { 890 int TclObjBeingDeleted(Tcl_Obj *objPtr) 891} 892declare 227 generic { 893 void TclSetNsPath(Namespace *nsPtr, int pathLength, 894 Tcl_Namespace *pathAry[]) 895} 896declare 228 generic { 897 int TclObjInterpProcCore(register Tcl_Interp *interp, Tcl_Obj *procNameObj, 898 int skip, ProcErrorProc errorProc) 899} 900declare 229 generic { 901 int TclPtrMakeUpvar(Tcl_Interp *interp, Var *otherP1Ptr, 902 CONST char *myName, int myFlags, int index) 903} 904declare 230 generic { 905 Var *TclObjLookupVar(Tcl_Interp *interp, Tcl_Obj *part1Ptr, 906 CONST char *part2, int flags, CONST char *msg, 907 CONST int createPart1, CONST int createPart2, Var **arrayPtrPtr) 908} 909declare 231 generic { 910 int TclGetNamespaceFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, 911 Tcl_Namespace **nsPtrPtr) 912} 913 914# Bits and pieces of TIP#280's guts 915declare 232 generic { 916 int TclEvalObjEx(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags, 917 CONST CmdFrame *invoker, int word) 918} 919declare 233 generic { 920 void TclGetSrcInfoForPc(CmdFrame *contextPtr) 921} 922 923# Exports for VarReform compat: Itcl, XOTcl like to peek into our varTables :( 924declare 234 generic { 925 Var *TclVarHashCreateVar(TclVarHashTable *tablePtr, CONST char *key, 926 int *newPtr) 927} 928declare 235 generic { 929 void TclInitVarHashTable(TclVarHashTable *tablePtr, Namespace *nsPtr) 930} 931 932 933# TIP 337 made this one public 934declare 236 generic { 935 void TclBackgroundException(Tcl_Interp *interp, int code) 936} 937 938# Tcl_Obj leak detection support. 939declare 243 generic { 940 void TclDbDumpActiveObjects(FILE *outFile) 941} 942 943 944############################################################################## 945 946# Define the platform specific internal Tcl interface. These functions are 947# only available on the designated platform. 948 949interface tclIntPlat 950 951################################ 952# Windows specific functions 953 954declare 0 win { 955 void TclWinConvertError(unsigned long errCode) 956} 957declare 1 win { 958 void TclWinConvertWSAError(unsigned long errCode) 959} 960declare 2 win { 961 struct servent *TclWinGetServByName(CONST char *nm, 962 CONST char *proto) 963} 964declare 3 win { 965 int TclWinGetSockOpt(int s, int level, int optname, 966 char FAR *optval, int FAR *optlen) 967} 968declare 4 win { 969 HINSTANCE TclWinGetTclInstance(void) 970} 971# Removed in 8.1: 972# declare 5 win { 973# HINSTANCE TclWinLoadLibrary(char *name) 974# } 975declare 6 win { 976 u_short TclWinNToHS(u_short ns) 977} 978declare 7 win { 979 int TclWinSetSockOpt(int s, int level, int optname, 980 CONST char FAR *optval, int optlen) 981} 982declare 8 win { 983 unsigned long TclpGetPid(Tcl_Pid pid) 984} 985declare 9 win { 986 int TclWinGetPlatformId(void) 987} 988# Removed in 8.3.1 (for Win32s only) 989#declare 10 win { 990# int TclWinSynchSpawn(void *args, int type, void **trans, Tcl_Pid *pidPtr) 991#} 992 993# Pipe channel functions 994 995declare 11 win { 996 void TclGetAndDetachPids(Tcl_Interp *interp, Tcl_Channel chan) 997} 998declare 12 win { 999 int TclpCloseFile(TclFile file) 1000} 1001declare 13 win { 1002 Tcl_Channel TclpCreateCommandChannel(TclFile readFile, 1003 TclFile writeFile, TclFile errorFile, int numPids, Tcl_Pid *pidPtr) 1004} 1005declare 14 win { 1006 int TclpCreatePipe(TclFile *readPipe, TclFile *writePipe) 1007} 1008declare 15 win { 1009 int TclpCreateProcess(Tcl_Interp *interp, int argc, CONST char **argv, 1010 TclFile inputFile, TclFile outputFile, TclFile errorFile, 1011 Tcl_Pid *pidPtr) 1012} 1013# Signature changed in 8.1: 1014# declare 16 win { 1015# TclFile TclpCreateTempFile(char *contents, Tcl_DString *namePtr) 1016# } 1017# declare 17 win { 1018# char *TclpGetTZName(void) 1019# } 1020declare 18 win { 1021 TclFile TclpMakeFile(Tcl_Channel channel, int direction) 1022} 1023declare 19 win { 1024 TclFile TclpOpenFile(CONST char *fname, int mode) 1025} 1026declare 20 win { 1027 void TclWinAddProcess(void *hProcess, unsigned long id) 1028} 1029 1030# removed permanently for 8.4 1031#declare 21 win { 1032# void TclpAsyncMark(Tcl_AsyncHandler async) 1033#} 1034 1035# Added in 8.1: 1036declare 22 win { 1037 TclFile TclpCreateTempFile(CONST char *contents) 1038} 1039declare 23 win { 1040 char *TclpGetTZName(int isdst) 1041} 1042declare 24 win { 1043 char *TclWinNoBackslash(char *path) 1044} 1045# replaced by generic TclGetPlatform 1046#declare 25 win { 1047# TclPlatformType *TclWinGetPlatform(void) 1048#} 1049declare 26 win { 1050 void TclWinSetInterfaces(int wide) 1051} 1052 1053# Added in Tcl 8.3.3 / 8.4 1054 1055declare 27 win { 1056 void TclWinFlushDirtyChannels(void) 1057} 1058 1059# Added in 8.4.2 1060 1061declare 28 win { 1062 void TclWinResetInterfaces(void) 1063} 1064declare 29 win { 1065 int TclWinCPUID(unsigned int index, unsigned int *regs) 1066} 1067 1068################################ 1069# Unix specific functions 1070 1071# Pipe channel functions 1072 1073declare 0 unix { 1074 void TclGetAndDetachPids(Tcl_Interp *interp, Tcl_Channel chan) 1075} 1076declare 1 unix { 1077 int TclpCloseFile(TclFile file) 1078} 1079declare 2 unix { 1080 Tcl_Channel TclpCreateCommandChannel(TclFile readFile, 1081 TclFile writeFile, TclFile errorFile, int numPids, Tcl_Pid *pidPtr) 1082} 1083declare 3 unix { 1084 int TclpCreatePipe(TclFile *readPipe, TclFile *writePipe) 1085} 1086declare 4 unix { 1087 int TclpCreateProcess(Tcl_Interp *interp, int argc, CONST char **argv, 1088 TclFile inputFile, TclFile outputFile, TclFile errorFile, 1089 Tcl_Pid *pidPtr) 1090} 1091# Signature changed in 8.1: 1092# declare 5 unix { 1093# TclFile TclpCreateTempFile(char *contents, Tcl_DString *namePtr) 1094# } 1095declare 6 unix { 1096 TclFile TclpMakeFile(Tcl_Channel channel, int direction) 1097} 1098declare 7 unix { 1099 TclFile TclpOpenFile(CONST char *fname, int mode) 1100} 1101declare 8 unix { 1102 int TclUnixWaitForFile(int fd, int mask, int timeout) 1103} 1104 1105# Added in 8.1: 1106 1107declare 9 unix { 1108 TclFile TclpCreateTempFile(CONST char *contents) 1109} 1110 1111# Added in 8.4: 1112 1113declare 10 unix { 1114 Tcl_DirEntry *TclpReaddir(DIR *dir) 1115} 1116# Slots 11 and 12 are forwarders for functions that were promoted to 1117# generic Stubs 1118declare 11 unix { 1119 struct tm *TclpLocaltime_unix(CONST time_t *clock) 1120} 1121declare 12 unix { 1122 struct tm *TclpGmtime_unix(CONST time_t *clock) 1123} 1124declare 13 unix { 1125 char *TclpInetNtoa(struct in_addr addr) 1126} 1127 1128# Added in 8.5: 1129 1130declare 14 unix { 1131 int TclUnixCopyFile(CONST char *src, CONST char *dst, 1132 CONST Tcl_StatBuf *statBufPtr, int dontCopyAtts) 1133} 1134 1135################################ 1136# Mac OS X specific functions 1137 1138declare 15 macosx { 1139 int TclMacOSXGetFileAttribute(Tcl_Interp *interp, int objIndex, 1140 Tcl_Obj *fileName, Tcl_Obj **attributePtrPtr) 1141} 1142declare 16 macosx { 1143 int TclMacOSXSetFileAttribute(Tcl_Interp *interp, int objIndex, 1144 Tcl_Obj *fileName, Tcl_Obj *attributePtr) 1145} 1146declare 17 macosx { 1147 int TclMacOSXCopyFileAttributes(CONST char *src, CONST char *dst, 1148 CONST Tcl_StatBuf *statBufPtr) 1149} 1150declare 18 macosx { 1151 int TclMacOSXMatchType(Tcl_Interp *interp, CONST char *pathName, 1152 CONST char *fileName, Tcl_StatBuf *statBufPtr, 1153 Tcl_GlobTypeData *types) 1154} 1155declare 19 macosx { 1156 void TclMacOSXNotifierAddRunLoopMode(CONST void *runLoopMode) 1157} 1158 1159 1160# Local Variables: 1161# mode: tcl 1162# End: 1163