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