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 2008/01/23 17:31:42 dgp Exp $ |
---|
17 | |
---|
18 | library tcl |
---|
19 | |
---|
20 | # Define the unsupported generic interfaces. |
---|
21 | |
---|
22 | interface 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 | #} |
---|
39 | declare 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 | # } |
---|
46 | declare 5 {unix win} { |
---|
47 | int TclCleanupChildren(Tcl_Interp *interp, int numPids, Tcl_Pid *pidPtr, |
---|
48 | Tcl_Channel errorChan) |
---|
49 | } |
---|
50 | declare 6 generic { |
---|
51 | void TclCleanupCommand(Command *cmdPtr) |
---|
52 | } |
---|
53 | declare 7 generic { |
---|
54 | int TclCopyAndCollapse(int count, CONST char *src, char *dst) |
---|
55 | } |
---|
56 | declare 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 | |
---|
63 | declare 9 {unix win} { |
---|
64 | int TclCreatePipeline(Tcl_Interp *interp, int argc, CONST char **argv, |
---|
65 | Tcl_Pid **pidArrayPtr, TclFile *inPipePtr, TclFile *outPipePtr, |
---|
66 | TclFile *errFilePtr) |
---|
67 | } |
---|
68 | declare 10 generic { |
---|
69 | int TclCreateProc(Tcl_Interp *interp, Namespace *nsPtr, |
---|
70 | CONST char *procName, |
---|
71 | Tcl_Obj *argsPtr, Tcl_Obj *bodyPtr, Proc **procPtrPtr) |
---|
72 | } |
---|
73 | declare 11 generic { |
---|
74 | void TclDeleteCompiledLocalVars(Interp *iPtr, CallFrame *framePtr) |
---|
75 | } |
---|
76 | declare 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 | #} |
---|
84 | declare 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 | # } |
---|
91 | declare 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 | #} |
---|
110 | declare 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 | } |
---|
115 | declare 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 | #} |
---|
122 | declare 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 | #} |
---|
134 | declare 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 | # } |
---|
146 | declare 31 generic { |
---|
147 | CONST char *TclGetExtension(CONST char *name) |
---|
148 | } |
---|
149 | declare 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 | #} |
---|
157 | declare 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 | #} |
---|
166 | declare 36 generic { |
---|
167 | int TclGetLong(Tcl_Interp *interp, CONST char *str, long *longPtr) |
---|
168 | } |
---|
169 | declare 37 generic { |
---|
170 | int TclGetLoadedPackages(Tcl_Interp *interp, char *targetName) |
---|
171 | } |
---|
172 | declare 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 | } |
---|
178 | declare 39 generic { |
---|
179 | TclObjCmdProcType TclGetObjInterpProc(void) |
---|
180 | } |
---|
181 | declare 40 generic { |
---|
182 | int TclGetOpenMode(Tcl_Interp *interp, CONST char *str, int *seekFlagPtr) |
---|
183 | } |
---|
184 | declare 41 generic { |
---|
185 | Tcl_Command TclGetOriginalCommand(Tcl_Command command) |
---|
186 | } |
---|
187 | declare 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 | #} |
---|
195 | declare 44 generic { |
---|
196 | int TclGuessPackageName(CONST char *fileName, Tcl_DString *bufPtr) |
---|
197 | } |
---|
198 | declare 45 generic { |
---|
199 | int TclHideUnsafeCommands(Tcl_Interp *interp) |
---|
200 | } |
---|
201 | declare 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 | #} |
---|
218 | declare 50 generic { |
---|
219 | void TclInitCompiledLocals(Tcl_Interp *interp, CallFrame *framePtr, |
---|
220 | Namespace *nsPtr) |
---|
221 | } |
---|
222 | declare 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 | #} |
---|
230 | declare 53 generic { |
---|
231 | int TclInvokeObjectCommand(ClientData clientData, Tcl_Interp *interp, |
---|
232 | int argc, CONST84 char **argv) |
---|
233 | } |
---|
234 | declare 54 generic { |
---|
235 | int TclInvokeStringCommand(ClientData clientData, Tcl_Interp *interp, |
---|
236 | int objc, Tcl_Obj *CONST objv[]) |
---|
237 | } |
---|
238 | declare 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 | # } |
---|
251 | declare 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 | #} |
---|
261 | declare 60 generic { |
---|
262 | int TclNeedSpace(CONST char *start, CONST char *end) |
---|
263 | } |
---|
264 | declare 61 generic { |
---|
265 | Tcl_Obj *TclNewProcBodyObj(Proc *procPtr) |
---|
266 | } |
---|
267 | declare 62 generic { |
---|
268 | int TclObjCommandComplete(Tcl_Obj *cmdPtr) |
---|
269 | } |
---|
270 | declare 63 generic { |
---|
271 | int TclObjInterpProc(ClientData clientData, Tcl_Interp *interp, |
---|
272 | int objc, Tcl_Obj *CONST objv[]) |
---|
273 | } |
---|
274 | declare 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 | #} |
---|
293 | declare 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 | #} |
---|
309 | declare 74 generic { |
---|
310 | void TclpFree(char *ptr) |
---|
311 | } |
---|
312 | declare 75 generic { |
---|
313 | unsigned long TclpGetClicks(void) |
---|
314 | } |
---|
315 | declare 76 generic { |
---|
316 | unsigned long TclpGetSeconds(void) |
---|
317 | } |
---|
318 | |
---|
319 | # deprecated |
---|
320 | declare 77 generic { |
---|
321 | void TclpGetTime(Tcl_Time *time) |
---|
322 | } |
---|
323 | declare 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 | #} |
---|
335 | declare 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 | # } |
---|
361 | declare 88 generic { |
---|
362 | char *TclPrecTraceProc(ClientData clientData, Tcl_Interp *interp, |
---|
363 | CONST char *name1, CONST char *name2, int flags) |
---|
364 | } |
---|
365 | declare 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 | # } |
---|
373 | declare 91 generic { |
---|
374 | void TclProcCleanupProc(Proc *procPtr) |
---|
375 | } |
---|
376 | declare 92 generic { |
---|
377 | int TclProcCompileProc(Tcl_Interp *interp, Proc *procPtr, |
---|
378 | Tcl_Obj *bodyPtr, Namespace *nsPtr, CONST char *description, |
---|
379 | CONST char *procName) |
---|
380 | } |
---|
381 | declare 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 | #} |
---|
393 | declare 96 generic { |
---|
394 | int TclRenameCommand(Tcl_Interp *interp, CONST char *oldName, |
---|
395 | CONST char *newName) |
---|
396 | } |
---|
397 | declare 97 generic { |
---|
398 | void TclResetShadowedCmdRefs(Tcl_Interp *interp, Command *newCmdPtr) |
---|
399 | } |
---|
400 | declare 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 | #} |
---|
413 | declare 101 generic { |
---|
414 | char *TclSetPreInitScript(char *string) |
---|
415 | } |
---|
416 | declare 102 generic { |
---|
417 | void TclSetupEnv(Tcl_Interp *interp) |
---|
418 | } |
---|
419 | declare 103 generic { |
---|
420 | int TclSockGetPort(Tcl_Interp *interp, CONST char *str, CONST char *proto, |
---|
421 | int *portPtr) |
---|
422 | } |
---|
423 | declare 104 {unix win} { |
---|
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 | #} |
---|
436 | declare 108 generic { |
---|
437 | void TclTeardownNamespace(Namespace *nsPtr) |
---|
438 | } |
---|
439 | declare 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 | |
---|
450 | declare 111 generic { |
---|
451 | void Tcl_AddInterpResolvers(Tcl_Interp *interp, CONST char *name, |
---|
452 | Tcl_ResolveCmdProc *cmdProc, Tcl_ResolveVarProc *varProc, |
---|
453 | Tcl_ResolveCompiledVarProc *compiledVarProc) |
---|
454 | } |
---|
455 | declare 112 generic { |
---|
456 | int Tcl_AppendExportList(Tcl_Interp *interp, Tcl_Namespace *nsPtr, |
---|
457 | Tcl_Obj *objPtr) |
---|
458 | } |
---|
459 | declare 113 generic { |
---|
460 | Tcl_Namespace *Tcl_CreateNamespace(Tcl_Interp *interp, CONST char *name, |
---|
461 | ClientData clientData, Tcl_NamespaceDeleteProc *deleteProc) |
---|
462 | } |
---|
463 | declare 114 generic { |
---|
464 | void Tcl_DeleteNamespace(Tcl_Namespace *nsPtr) |
---|
465 | } |
---|
466 | declare 115 generic { |
---|
467 | int Tcl_Export(Tcl_Interp *interp, Tcl_Namespace *nsPtr, |
---|
468 | CONST char *pattern, int resetListFirst) |
---|
469 | } |
---|
470 | declare 116 generic { |
---|
471 | Tcl_Command Tcl_FindCommand(Tcl_Interp *interp, CONST char *name, |
---|
472 | Tcl_Namespace *contextNsPtr, int flags) |
---|
473 | } |
---|
474 | declare 117 generic { |
---|
475 | Tcl_Namespace *Tcl_FindNamespace(Tcl_Interp *interp, CONST char *name, |
---|
476 | Tcl_Namespace *contextNsPtr, int flags) |
---|
477 | } |
---|
478 | declare 118 generic { |
---|
479 | int Tcl_GetInterpResolvers(Tcl_Interp *interp, CONST char *name, |
---|
480 | Tcl_ResolverInfo *resInfo) |
---|
481 | } |
---|
482 | declare 119 generic { |
---|
483 | int Tcl_GetNamespaceResolvers(Tcl_Namespace *namespacePtr, |
---|
484 | Tcl_ResolverInfo *resInfo) |
---|
485 | } |
---|
486 | declare 120 generic { |
---|
487 | Tcl_Var Tcl_FindNamespaceVar(Tcl_Interp *interp, CONST char *name, |
---|
488 | Tcl_Namespace *contextNsPtr, int flags) |
---|
489 | } |
---|
490 | declare 121 generic { |
---|
491 | int Tcl_ForgetImport(Tcl_Interp *interp, Tcl_Namespace *nsPtr, |
---|
492 | CONST char *pattern) |
---|
493 | } |
---|
494 | declare 122 generic { |
---|
495 | Tcl_Command Tcl_GetCommandFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr) |
---|
496 | } |
---|
497 | declare 123 generic { |
---|
498 | void Tcl_GetCommandFullName(Tcl_Interp *interp, Tcl_Command command, |
---|
499 | Tcl_Obj *objPtr) |
---|
500 | } |
---|
501 | declare 124 generic { |
---|
502 | Tcl_Namespace *Tcl_GetCurrentNamespace(Tcl_Interp *interp) |
---|
503 | } |
---|
504 | declare 125 generic { |
---|
505 | Tcl_Namespace *Tcl_GetGlobalNamespace(Tcl_Interp *interp) |
---|
506 | } |
---|
507 | declare 126 generic { |
---|
508 | void Tcl_GetVariableFullName(Tcl_Interp *interp, Tcl_Var variable, |
---|
509 | Tcl_Obj *objPtr) |
---|
510 | } |
---|
511 | declare 127 generic { |
---|
512 | int Tcl_Import(Tcl_Interp *interp, Tcl_Namespace *nsPtr, |
---|
513 | CONST char *pattern, int allowOverwrite) |
---|
514 | } |
---|
515 | declare 128 generic { |
---|
516 | void Tcl_PopCallFrame(Tcl_Interp *interp) |
---|
517 | } |
---|
518 | declare 129 generic { |
---|
519 | int Tcl_PushCallFrame(Tcl_Interp *interp, Tcl_CallFrame *framePtr, |
---|
520 | Tcl_Namespace *nsPtr, int isProcCallFrame) |
---|
521 | } |
---|
522 | declare 130 generic { |
---|
523 | int Tcl_RemoveInterpResolvers(Tcl_Interp *interp, CONST char *name) |
---|
524 | } |
---|
525 | declare 131 generic { |
---|
526 | void Tcl_SetNamespaceResolvers(Tcl_Namespace *namespacePtr, |
---|
527 | Tcl_ResolveCmdProc *cmdProc, Tcl_ResolveVarProc *varProc, |
---|
528 | Tcl_ResolveCompiledVarProc *compiledVarProc) |
---|
529 | } |
---|
530 | declare 132 generic { |
---|
531 | int TclpHasSockets(Tcl_Interp *interp) |
---|
532 | } |
---|
533 | declare 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 | #} |
---|
550 | declare 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 |
---|
562 | declare 141 generic { |
---|
563 | CONST84_RETURN char *TclpGetCwd(Tcl_Interp *interp, Tcl_DString *cwdPtr) |
---|
564 | } |
---|
565 | declare 142 generic { |
---|
566 | int TclSetByteCodeFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr, |
---|
567 | CompileHookProc *hookProc, ClientData clientData) |
---|
568 | } |
---|
569 | declare 143 generic { |
---|
570 | int TclAddLiteralObj(struct CompileEnv *envPtr, Tcl_Obj *objPtr, |
---|
571 | LiteralEntry **litPtrPtr) |
---|
572 | } |
---|
573 | declare 144 generic { |
---|
574 | void TclHideLiteral(Tcl_Interp *interp, struct CompileEnv *envPtr, |
---|
575 | int index) |
---|
576 | } |
---|
577 | declare 145 generic { |
---|
578 | struct AuxDataType *TclGetAuxDataType(char *typeName) |
---|
579 | } |
---|
580 | declare 146 generic { |
---|
581 | TclHandle TclHandleCreate(VOID *ptr) |
---|
582 | } |
---|
583 | declare 147 generic { |
---|
584 | void TclHandleFree(TclHandle handle) |
---|
585 | } |
---|
586 | declare 148 generic { |
---|
587 | TclHandle TclHandlePreserve(TclHandle handle) |
---|
588 | } |
---|
589 | declare 149 generic { |
---|
590 | void TclHandleRelease(TclHandle handle) |
---|
591 | } |
---|
592 | |
---|
593 | # Added for Tcl 8.2 |
---|
594 | |
---|
595 | declare 150 generic { |
---|
596 | int TclRegAbout(Tcl_Interp *interp, Tcl_RegExp re) |
---|
597 | } |
---|
598 | declare 151 generic { |
---|
599 | void TclRegExpRangeUniChar(Tcl_RegExp re, int index, int *startPtr, |
---|
600 | int *endPtr) |
---|
601 | } |
---|
602 | declare 152 generic { |
---|
603 | void TclSetLibraryPath(Tcl_Obj *pathPtr) |
---|
604 | } |
---|
605 | declare 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 | |
---|
619 | declare 156 generic { |
---|
620 | void TclRegError(Tcl_Interp *interp, CONST char *msg, |
---|
621 | int status) |
---|
622 | } |
---|
623 | declare 157 generic { |
---|
624 | Var *TclVarTraceExists(Tcl_Interp *interp, CONST char *varName) |
---|
625 | } |
---|
626 | declare 158 generic { |
---|
627 | void TclSetStartupScriptFileName(CONST char *filename) |
---|
628 | } |
---|
629 | declare 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 |
---|
639 | declare 161 generic { |
---|
640 | int TclChannelTransform(Tcl_Interp *interp, Tcl_Channel chan, |
---|
641 | Tcl_Obj *cmdObjPtr) |
---|
642 | } |
---|
643 | declare 162 generic { |
---|
644 | void TclChannelEventScriptInvoker(ClientData clientData, int flags) |
---|
645 | } |
---|
646 | |
---|
647 | # ALERT: The result of 'TclGetInstructionTable' is actually an |
---|
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 | |
---|
652 | declare 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 | |
---|
660 | declare 164 generic { |
---|
661 | void TclExpandCodeArray(void *envPtr) |
---|
662 | } |
---|
663 | |
---|
664 | # These functions are vfs aware, but are generally only useful internally. |
---|
665 | declare 165 generic { |
---|
666 | void TclpSetInitialEncodings(void) |
---|
667 | } |
---|
668 | |
---|
669 | # New function due to TIP #33 |
---|
670 | declare 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) |
---|
676 | declare 167 generic { |
---|
677 | void TclSetStartupScriptPath(Tcl_Obj *pathPtr) |
---|
678 | } |
---|
679 | declare 168 generic { |
---|
680 | Tcl_Obj *TclGetStartupScriptPath(void) |
---|
681 | } |
---|
682 | # variant of Tcl_UtfNCmp that takes n as bytes, not chars |
---|
683 | declare 169 generic { |
---|
684 | int TclpUtfNcmp2(CONST char *s1, CONST char *s2, unsigned long n) |
---|
685 | } |
---|
686 | declare 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 | } |
---|
691 | declare 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 | } |
---|
696 | declare 172 generic { |
---|
697 | int TclInThreadExit(void) |
---|
698 | } |
---|
699 | |
---|
700 | # added for 8.4.2 |
---|
701 | |
---|
702 | declare 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 | |
---|
716 | declare 175 generic { |
---|
717 | int TclCallVarTraces(Interp *iPtr, Var *arrayPtr, Var *varPtr, |
---|
718 | CONST char *part1, CONST char *part2, int flags, int leaveErrMsg) |
---|
719 | } |
---|
720 | declare 176 generic { |
---|
721 | void TclCleanupVar(Var *varPtr, Var *arrayPtr) |
---|
722 | } |
---|
723 | declare 177 generic { |
---|
724 | void TclVarErrMsg(Tcl_Interp *interp, CONST char *part1, CONST char *part2, |
---|
725 | CONST char *operation, CONST char *reason) |
---|
726 | } |
---|
727 | declare 178 generic { |
---|
728 | void Tcl_SetStartupScript(Tcl_Obj *pathPtr, CONST char* encodingName) |
---|
729 | } |
---|
730 | declare 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 | |
---|
746 | declare 182 generic { |
---|
747 | struct tm *TclpLocaltime(CONST time_t *clock) |
---|
748 | } |
---|
749 | declare 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 | #} |
---|
806 | declare 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] |
---|
816 | declare 200 generic { |
---|
817 | int TclpObjRemoveDirectory(Tcl_Obj *pathPtr, int recursive, |
---|
818 | Tcl_Obj **errorPtr) |
---|
819 | } |
---|
820 | declare 201 generic { |
---|
821 | int TclpObjCopyDirectory(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr, |
---|
822 | Tcl_Obj **errorPtr) |
---|
823 | } |
---|
824 | declare 202 generic { |
---|
825 | int TclpObjCreateDirectory(Tcl_Obj *pathPtr) |
---|
826 | } |
---|
827 | declare 203 generic { |
---|
828 | int TclpObjDeleteFile(Tcl_Obj *pathPtr) |
---|
829 | } |
---|
830 | declare 204 generic { |
---|
831 | int TclpObjCopyFile(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr) |
---|
832 | } |
---|
833 | declare 205 generic { |
---|
834 | int TclpObjRenameFile(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr) |
---|
835 | } |
---|
836 | declare 206 generic { |
---|
837 | int TclpObjStat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf) |
---|
838 | } |
---|
839 | declare 207 generic { |
---|
840 | int TclpObjAccess(Tcl_Obj *pathPtr, int mode) |
---|
841 | } |
---|
842 | declare 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 | #} |
---|
856 | declare 212 generic { |
---|
857 | void TclpFindExecutable(CONST char *argv0) |
---|
858 | } |
---|
859 | declare 213 generic { |
---|
860 | Tcl_Obj * TclGetObjNameOfExecutable(void) |
---|
861 | } |
---|
862 | declare 214 generic { |
---|
863 | void TclSetObjNameOfExecutable(Tcl_Obj *name, Tcl_Encoding encoding) |
---|
864 | } |
---|
865 | declare 215 generic { |
---|
866 | void * TclStackAlloc(Tcl_Interp *interp, int numBytes) |
---|
867 | } |
---|
868 | declare 216 generic { |
---|
869 | void TclStackFree(Tcl_Interp *interp, void *freePtr) |
---|
870 | } |
---|
871 | declare 217 generic { |
---|
872 | int TclPushStackFrame(Tcl_Interp *interp, Tcl_CallFrame **framePtrPtr, |
---|
873 | Tcl_Namespace *namespacePtr, int isProcCallFrame ) |
---|
874 | } |
---|
875 | declare 218 generic { |
---|
876 | void TclPopStackFrame(Tcl_Interp *interp) |
---|
877 | } |
---|
878 | |
---|
879 | # for use in tclTest.c |
---|
880 | declare 224 generic { |
---|
881 | TclPlatformType *TclGetPlatform(void) |
---|
882 | } |
---|
883 | |
---|
884 | # |
---|
885 | declare 225 generic { |
---|
886 | Tcl_Obj *TclTraceDictPath(Tcl_Interp *interp, Tcl_Obj *rootPtr, |
---|
887 | int keyc, Tcl_Obj *CONST keyv[], int flags) |
---|
888 | } |
---|
889 | declare 226 generic { |
---|
890 | int TclObjBeingDeleted(Tcl_Obj *objPtr) |
---|
891 | } |
---|
892 | declare 227 generic { |
---|
893 | void TclSetNsPath(Namespace *nsPtr, int pathLength, |
---|
894 | Tcl_Namespace *pathAry[]) |
---|
895 | } |
---|
896 | declare 228 generic { |
---|
897 | int TclObjInterpProcCore(register Tcl_Interp *interp, Tcl_Obj *procNameObj, |
---|
898 | int skip, ProcErrorProc errorProc) |
---|
899 | } |
---|
900 | declare 229 generic { |
---|
901 | int TclPtrMakeUpvar(Tcl_Interp *interp, Var *otherP1Ptr, |
---|
902 | CONST char *myName, int myFlags, int index) |
---|
903 | } |
---|
904 | declare 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 | } |
---|
909 | declare 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 |
---|
915 | declare 232 generic { |
---|
916 | int TclEvalObjEx(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags, |
---|
917 | const CmdFrame *invoker, int word) |
---|
918 | } |
---|
919 | declare 233 generic { |
---|
920 | void TclGetSrcInfoForPc(CmdFrame *contextPtr) |
---|
921 | } |
---|
922 | |
---|
923 | # Exports for VarReform compat: Itcl, XOTcl like to peek into our varTables :( |
---|
924 | declare 234 generic { |
---|
925 | Var *TclVarHashCreateVar(TclVarHashTable *tablePtr, const char *key, |
---|
926 | int *newPtr) |
---|
927 | } |
---|
928 | declare 235 generic { |
---|
929 | void TclInitVarHashTable(TclVarHashTable *tablePtr, Namespace *nsPtr) |
---|
930 | } |
---|
931 | |
---|
932 | |
---|
933 | declare 236 generic { |
---|
934 | void TclBackgroundException(Tcl_Interp *interp, int code) |
---|
935 | } |
---|
936 | |
---|
937 | ############################################################################## |
---|
938 | |
---|
939 | # Define the platform specific internal Tcl interface. These functions are |
---|
940 | # only available on the designated platform. |
---|
941 | |
---|
942 | interface tclIntPlat |
---|
943 | |
---|
944 | ################################ |
---|
945 | # Windows specific functions |
---|
946 | |
---|
947 | declare 0 win { |
---|
948 | void TclWinConvertError(DWORD errCode) |
---|
949 | } |
---|
950 | declare 1 win { |
---|
951 | void TclWinConvertWSAError(DWORD errCode) |
---|
952 | } |
---|
953 | declare 2 win { |
---|
954 | struct servent *TclWinGetServByName(CONST char *nm, |
---|
955 | CONST char *proto) |
---|
956 | } |
---|
957 | declare 3 win { |
---|
958 | int TclWinGetSockOpt(int s, int level, int optname, |
---|
959 | char FAR *optval, int FAR *optlen) |
---|
960 | } |
---|
961 | declare 4 win { |
---|
962 | HINSTANCE TclWinGetTclInstance(void) |
---|
963 | } |
---|
964 | # Removed in 8.1: |
---|
965 | # declare 5 win { |
---|
966 | # HINSTANCE TclWinLoadLibrary(char *name) |
---|
967 | # } |
---|
968 | declare 6 win { |
---|
969 | u_short TclWinNToHS(u_short ns) |
---|
970 | } |
---|
971 | declare 7 win { |
---|
972 | int TclWinSetSockOpt(int s, int level, int optname, |
---|
973 | CONST char FAR *optval, int optlen) |
---|
974 | } |
---|
975 | declare 8 win { |
---|
976 | unsigned long TclpGetPid(Tcl_Pid pid) |
---|
977 | } |
---|
978 | declare 9 win { |
---|
979 | int TclWinGetPlatformId(void) |
---|
980 | } |
---|
981 | # Removed in 8.3.1 (for Win32s only) |
---|
982 | #declare 10 win { |
---|
983 | # int TclWinSynchSpawn(void *args, int type, void **trans, Tcl_Pid *pidPtr) |
---|
984 | #} |
---|
985 | |
---|
986 | # Pipe channel functions |
---|
987 | |
---|
988 | declare 11 win { |
---|
989 | void TclGetAndDetachPids(Tcl_Interp *interp, Tcl_Channel chan) |
---|
990 | } |
---|
991 | declare 12 win { |
---|
992 | int TclpCloseFile(TclFile file) |
---|
993 | } |
---|
994 | declare 13 win { |
---|
995 | Tcl_Channel TclpCreateCommandChannel(TclFile readFile, |
---|
996 | TclFile writeFile, TclFile errorFile, int numPids, Tcl_Pid *pidPtr) |
---|
997 | } |
---|
998 | declare 14 win { |
---|
999 | int TclpCreatePipe(TclFile *readPipe, TclFile *writePipe) |
---|
1000 | } |
---|
1001 | declare 15 win { |
---|
1002 | int TclpCreateProcess(Tcl_Interp *interp, int argc, CONST char **argv, |
---|
1003 | TclFile inputFile, TclFile outputFile, TclFile errorFile, |
---|
1004 | Tcl_Pid *pidPtr) |
---|
1005 | } |
---|
1006 | # Signature changed in 8.1: |
---|
1007 | # declare 16 win { |
---|
1008 | # TclFile TclpCreateTempFile(char *contents, Tcl_DString *namePtr) |
---|
1009 | # } |
---|
1010 | # declare 17 win { |
---|
1011 | # char *TclpGetTZName(void) |
---|
1012 | # } |
---|
1013 | declare 18 win { |
---|
1014 | TclFile TclpMakeFile(Tcl_Channel channel, int direction) |
---|
1015 | } |
---|
1016 | declare 19 win { |
---|
1017 | TclFile TclpOpenFile(CONST char *fname, int mode) |
---|
1018 | } |
---|
1019 | declare 20 win { |
---|
1020 | void TclWinAddProcess(HANDLE hProcess, DWORD id) |
---|
1021 | } |
---|
1022 | |
---|
1023 | # removed permanently for 8.4 |
---|
1024 | #declare 21 win { |
---|
1025 | # void TclpAsyncMark(Tcl_AsyncHandler async) |
---|
1026 | #} |
---|
1027 | |
---|
1028 | # Added in 8.1: |
---|
1029 | declare 22 win { |
---|
1030 | TclFile TclpCreateTempFile(CONST char *contents) |
---|
1031 | } |
---|
1032 | declare 23 win { |
---|
1033 | char *TclpGetTZName(int isdst) |
---|
1034 | } |
---|
1035 | declare 24 win { |
---|
1036 | char *TclWinNoBackslash(char *path) |
---|
1037 | } |
---|
1038 | # replaced by generic TclGetPlatform |
---|
1039 | #declare 25 win { |
---|
1040 | # TclPlatformType *TclWinGetPlatform(void) |
---|
1041 | #} |
---|
1042 | declare 26 win { |
---|
1043 | void TclWinSetInterfaces(int wide) |
---|
1044 | } |
---|
1045 | |
---|
1046 | # Added in Tcl 8.3.3 / 8.4 |
---|
1047 | |
---|
1048 | declare 27 win { |
---|
1049 | void TclWinFlushDirtyChannels(void) |
---|
1050 | } |
---|
1051 | |
---|
1052 | # Added in 8.4.2 |
---|
1053 | |
---|
1054 | declare 28 win { |
---|
1055 | void TclWinResetInterfaces(void) |
---|
1056 | } |
---|
1057 | declare 29 win { |
---|
1058 | int TclWinCPUID( unsigned int index, unsigned int *regs ) |
---|
1059 | } |
---|
1060 | |
---|
1061 | ################################ |
---|
1062 | # Unix specific functions |
---|
1063 | |
---|
1064 | # Pipe channel functions |
---|
1065 | |
---|
1066 | declare 0 unix { |
---|
1067 | void TclGetAndDetachPids(Tcl_Interp *interp, Tcl_Channel chan) |
---|
1068 | } |
---|
1069 | declare 1 unix { |
---|
1070 | int TclpCloseFile(TclFile file) |
---|
1071 | } |
---|
1072 | declare 2 unix { |
---|
1073 | Tcl_Channel TclpCreateCommandChannel(TclFile readFile, |
---|
1074 | TclFile writeFile, TclFile errorFile, int numPids, Tcl_Pid *pidPtr) |
---|
1075 | } |
---|
1076 | declare 3 unix { |
---|
1077 | int TclpCreatePipe(TclFile *readPipe, TclFile *writePipe) |
---|
1078 | } |
---|
1079 | declare 4 unix { |
---|
1080 | int TclpCreateProcess(Tcl_Interp *interp, int argc, CONST char **argv, |
---|
1081 | TclFile inputFile, TclFile outputFile, TclFile errorFile, |
---|
1082 | Tcl_Pid *pidPtr) |
---|
1083 | } |
---|
1084 | # Signature changed in 8.1: |
---|
1085 | # declare 5 unix { |
---|
1086 | # TclFile TclpCreateTempFile(char *contents, Tcl_DString *namePtr) |
---|
1087 | # } |
---|
1088 | declare 6 unix { |
---|
1089 | TclFile TclpMakeFile(Tcl_Channel channel, int direction) |
---|
1090 | } |
---|
1091 | declare 7 unix { |
---|
1092 | TclFile TclpOpenFile(CONST char *fname, int mode) |
---|
1093 | } |
---|
1094 | declare 8 unix { |
---|
1095 | int TclUnixWaitForFile(int fd, int mask, int timeout) |
---|
1096 | } |
---|
1097 | |
---|
1098 | # Added in 8.1: |
---|
1099 | |
---|
1100 | declare 9 unix { |
---|
1101 | TclFile TclpCreateTempFile(CONST char *contents) |
---|
1102 | } |
---|
1103 | |
---|
1104 | # Added in 8.4: |
---|
1105 | |
---|
1106 | declare 10 unix { |
---|
1107 | Tcl_DirEntry *TclpReaddir(DIR *dir) |
---|
1108 | } |
---|
1109 | # Slots 11 and 12 are forwarders for functions that were promoted to |
---|
1110 | # generic Stubs |
---|
1111 | declare 11 unix { |
---|
1112 | struct tm *TclpLocaltime_unix(CONST time_t *clock) |
---|
1113 | } |
---|
1114 | declare 12 unix { |
---|
1115 | struct tm *TclpGmtime_unix(CONST time_t *clock) |
---|
1116 | } |
---|
1117 | declare 13 unix { |
---|
1118 | char *TclpInetNtoa(struct in_addr addr) |
---|
1119 | } |
---|
1120 | |
---|
1121 | # Added in 8.5: |
---|
1122 | |
---|
1123 | declare 14 unix { |
---|
1124 | int TclUnixCopyFile(CONST char *src, CONST char *dst, |
---|
1125 | CONST Tcl_StatBuf *statBufPtr, int dontCopyAtts) |
---|
1126 | } |
---|
1127 | |
---|
1128 | ################################ |
---|
1129 | # Mac OS X specific functions |
---|
1130 | |
---|
1131 | declare 15 macosx { |
---|
1132 | int TclMacOSXGetFileAttribute(Tcl_Interp *interp, int objIndex, |
---|
1133 | Tcl_Obj *fileName, Tcl_Obj **attributePtrPtr) |
---|
1134 | } |
---|
1135 | declare 16 macosx { |
---|
1136 | int TclMacOSXSetFileAttribute(Tcl_Interp *interp, int objIndex, |
---|
1137 | Tcl_Obj *fileName, Tcl_Obj *attributePtr) |
---|
1138 | } |
---|
1139 | declare 17 macosx { |
---|
1140 | int TclMacOSXCopyFileAttributes(CONST char *src, CONST char *dst, |
---|
1141 | CONST Tcl_StatBuf *statBufPtr) |
---|
1142 | } |
---|
1143 | declare 18 macosx { |
---|
1144 | int TclMacOSXMatchType(Tcl_Interp *interp, CONST char *pathName, |
---|
1145 | CONST char *fileName, Tcl_StatBuf *statBufPtr, |
---|
1146 | Tcl_GlobTypeData *types) |
---|
1147 | } |
---|