1 | # tcl.decls -- |
---|
2 | # |
---|
3 | # This file contains the declarations for all supported public |
---|
4 | # functions that are exported by the Tcl library via the stubs table. |
---|
5 | # This file is used to generate the tclDecls.h, tclPlatDecls.h, |
---|
6 | # tclStub.c, and tclPlatStub.c files. |
---|
7 | # |
---|
8 | # Copyright (c) 1998-1999 by Scriptics Corporation. |
---|
9 | # Copyright (c) 2001, 2002 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 | # |
---|
15 | # RCS: @(#) $Id: tcl.decls,v 1.131 2008/03/19 16:56:13 das Exp $ |
---|
16 | |
---|
17 | library tcl |
---|
18 | |
---|
19 | # Define the tcl interface with several sub interfaces: |
---|
20 | # tclPlat - platform specific public |
---|
21 | # tclInt - generic private |
---|
22 | # tclPlatInt - platform specific private |
---|
23 | |
---|
24 | interface tcl |
---|
25 | hooks {tclPlat tclInt tclIntPlat} |
---|
26 | |
---|
27 | # Declare each of the functions in the public Tcl interface. Note that |
---|
28 | # the an index should never be reused for a different function in order |
---|
29 | # to preserve backwards compatibility. |
---|
30 | |
---|
31 | declare 0 generic { |
---|
32 | int Tcl_PkgProvideEx(Tcl_Interp* interp, CONST char* name, |
---|
33 | CONST char* version, ClientData clientData) |
---|
34 | } |
---|
35 | declare 1 generic { |
---|
36 | CONST84_RETURN char * Tcl_PkgRequireEx(Tcl_Interp *interp, |
---|
37 | CONST char *name, CONST char *version, int exact, |
---|
38 | ClientData *clientDataPtr) |
---|
39 | } |
---|
40 | declare 2 generic { |
---|
41 | void Tcl_Panic(CONST char *format, ...) |
---|
42 | } |
---|
43 | declare 3 generic { |
---|
44 | char * Tcl_Alloc(unsigned int size) |
---|
45 | } |
---|
46 | declare 4 generic { |
---|
47 | void Tcl_Free(char *ptr) |
---|
48 | } |
---|
49 | declare 5 generic { |
---|
50 | char * Tcl_Realloc(char *ptr, unsigned int size) |
---|
51 | } |
---|
52 | declare 6 generic { |
---|
53 | char * Tcl_DbCkalloc(unsigned int size, CONST char *file, int line) |
---|
54 | } |
---|
55 | declare 7 generic { |
---|
56 | int Tcl_DbCkfree(char *ptr, CONST char *file, int line) |
---|
57 | } |
---|
58 | declare 8 generic { |
---|
59 | char * Tcl_DbCkrealloc(char *ptr, unsigned int size, |
---|
60 | CONST char *file, int line) |
---|
61 | } |
---|
62 | |
---|
63 | # Tcl_CreateFileHandler and Tcl_DeleteFileHandler are only available on unix, |
---|
64 | # but they are part of the old generic interface, so we include them here for |
---|
65 | # compatibility reasons. |
---|
66 | |
---|
67 | declare 9 unix { |
---|
68 | void Tcl_CreateFileHandler(int fd, int mask, Tcl_FileProc *proc, |
---|
69 | ClientData clientData) |
---|
70 | } |
---|
71 | declare 10 unix { |
---|
72 | void Tcl_DeleteFileHandler(int fd) |
---|
73 | } |
---|
74 | declare 11 generic { |
---|
75 | void Tcl_SetTimer(Tcl_Time *timePtr) |
---|
76 | } |
---|
77 | declare 12 generic { |
---|
78 | void Tcl_Sleep(int ms) |
---|
79 | } |
---|
80 | declare 13 generic { |
---|
81 | int Tcl_WaitForEvent(Tcl_Time *timePtr) |
---|
82 | } |
---|
83 | declare 14 generic { |
---|
84 | int Tcl_AppendAllObjTypes(Tcl_Interp *interp, Tcl_Obj *objPtr) |
---|
85 | } |
---|
86 | declare 15 generic { |
---|
87 | void Tcl_AppendStringsToObj(Tcl_Obj *objPtr, ...) |
---|
88 | } |
---|
89 | declare 16 generic { |
---|
90 | void Tcl_AppendToObj(Tcl_Obj* objPtr, CONST char* bytes, int length) |
---|
91 | } |
---|
92 | declare 17 generic { |
---|
93 | Tcl_Obj * Tcl_ConcatObj(int objc, Tcl_Obj *CONST objv[]) |
---|
94 | } |
---|
95 | declare 18 generic { |
---|
96 | int Tcl_ConvertToType(Tcl_Interp *interp, Tcl_Obj *objPtr, |
---|
97 | Tcl_ObjType *typePtr) |
---|
98 | } |
---|
99 | declare 19 generic { |
---|
100 | void Tcl_DbDecrRefCount(Tcl_Obj *objPtr, CONST char *file, int line) |
---|
101 | } |
---|
102 | declare 20 generic { |
---|
103 | void Tcl_DbIncrRefCount(Tcl_Obj *objPtr, CONST char *file, int line) |
---|
104 | } |
---|
105 | declare 21 generic { |
---|
106 | int Tcl_DbIsShared(Tcl_Obj *objPtr, CONST char *file, int line) |
---|
107 | } |
---|
108 | declare 22 generic { |
---|
109 | Tcl_Obj * Tcl_DbNewBooleanObj(int boolValue, CONST char *file, int line) |
---|
110 | } |
---|
111 | declare 23 generic { |
---|
112 | Tcl_Obj * Tcl_DbNewByteArrayObj(CONST unsigned char *bytes, int length, |
---|
113 | CONST char *file, int line) |
---|
114 | } |
---|
115 | declare 24 generic { |
---|
116 | Tcl_Obj * Tcl_DbNewDoubleObj(double doubleValue, |
---|
117 | CONST char *file, int line) |
---|
118 | } |
---|
119 | declare 25 generic { |
---|
120 | Tcl_Obj * Tcl_DbNewListObj(int objc, Tcl_Obj *CONST *objv, |
---|
121 | CONST char *file, int line) |
---|
122 | } |
---|
123 | declare 26 generic { |
---|
124 | Tcl_Obj * Tcl_DbNewLongObj(long longValue, CONST char *file, int line) |
---|
125 | } |
---|
126 | declare 27 generic { |
---|
127 | Tcl_Obj * Tcl_DbNewObj(CONST char *file, int line) |
---|
128 | } |
---|
129 | declare 28 generic { |
---|
130 | Tcl_Obj * Tcl_DbNewStringObj(CONST char *bytes, int length, |
---|
131 | CONST char *file, int line) |
---|
132 | } |
---|
133 | declare 29 generic { |
---|
134 | Tcl_Obj * Tcl_DuplicateObj(Tcl_Obj *objPtr) |
---|
135 | } |
---|
136 | declare 30 generic { |
---|
137 | void TclFreeObj(Tcl_Obj *objPtr) |
---|
138 | } |
---|
139 | declare 31 generic { |
---|
140 | int Tcl_GetBoolean(Tcl_Interp *interp, CONST char *src, int *boolPtr) |
---|
141 | } |
---|
142 | declare 32 generic { |
---|
143 | int Tcl_GetBooleanFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, |
---|
144 | int *boolPtr) |
---|
145 | } |
---|
146 | declare 33 generic { |
---|
147 | unsigned char * Tcl_GetByteArrayFromObj(Tcl_Obj *objPtr, int *lengthPtr) |
---|
148 | } |
---|
149 | declare 34 generic { |
---|
150 | int Tcl_GetDouble(Tcl_Interp *interp, CONST char *src, double *doublePtr) |
---|
151 | } |
---|
152 | declare 35 generic { |
---|
153 | int Tcl_GetDoubleFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, |
---|
154 | double *doublePtr) |
---|
155 | } |
---|
156 | declare 36 generic { |
---|
157 | int Tcl_GetIndexFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, |
---|
158 | CONST84 char **tablePtr, CONST char *msg, int flags, int *indexPtr) |
---|
159 | } |
---|
160 | declare 37 generic { |
---|
161 | int Tcl_GetInt(Tcl_Interp *interp, CONST char *src, int *intPtr) |
---|
162 | } |
---|
163 | declare 38 generic { |
---|
164 | int Tcl_GetIntFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *intPtr) |
---|
165 | } |
---|
166 | declare 39 generic { |
---|
167 | int Tcl_GetLongFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, long *longPtr) |
---|
168 | } |
---|
169 | declare 40 generic { |
---|
170 | Tcl_ObjType * Tcl_GetObjType(CONST char *typeName) |
---|
171 | } |
---|
172 | declare 41 generic { |
---|
173 | char * Tcl_GetStringFromObj(Tcl_Obj *objPtr, int *lengthPtr) |
---|
174 | } |
---|
175 | declare 42 generic { |
---|
176 | void Tcl_InvalidateStringRep(Tcl_Obj *objPtr) |
---|
177 | } |
---|
178 | declare 43 generic { |
---|
179 | int Tcl_ListObjAppendList(Tcl_Interp *interp, Tcl_Obj *listPtr, |
---|
180 | Tcl_Obj *elemListPtr) |
---|
181 | } |
---|
182 | declare 44 generic { |
---|
183 | int Tcl_ListObjAppendElement(Tcl_Interp *interp, Tcl_Obj *listPtr, |
---|
184 | Tcl_Obj *objPtr) |
---|
185 | } |
---|
186 | declare 45 generic { |
---|
187 | int Tcl_ListObjGetElements(Tcl_Interp *interp, Tcl_Obj *listPtr, |
---|
188 | int *objcPtr, Tcl_Obj ***objvPtr) |
---|
189 | } |
---|
190 | declare 46 generic { |
---|
191 | int Tcl_ListObjIndex(Tcl_Interp *interp, Tcl_Obj *listPtr, int index, |
---|
192 | Tcl_Obj **objPtrPtr) |
---|
193 | } |
---|
194 | declare 47 generic { |
---|
195 | int Tcl_ListObjLength(Tcl_Interp *interp, Tcl_Obj *listPtr, |
---|
196 | int *lengthPtr) |
---|
197 | } |
---|
198 | declare 48 generic { |
---|
199 | int Tcl_ListObjReplace(Tcl_Interp *interp, Tcl_Obj *listPtr, int first, |
---|
200 | int count, int objc, Tcl_Obj *CONST objv[]) |
---|
201 | } |
---|
202 | declare 49 generic { |
---|
203 | Tcl_Obj *Tcl_NewBooleanObj(int boolValue) |
---|
204 | } |
---|
205 | declare 50 generic { |
---|
206 | Tcl_Obj *Tcl_NewByteArrayObj(CONST unsigned char* bytes, int length) |
---|
207 | } |
---|
208 | declare 51 generic { |
---|
209 | Tcl_Obj * Tcl_NewDoubleObj(double doubleValue) |
---|
210 | } |
---|
211 | declare 52 generic { |
---|
212 | Tcl_Obj * Tcl_NewIntObj(int intValue) |
---|
213 | } |
---|
214 | declare 53 generic { |
---|
215 | Tcl_Obj * Tcl_NewListObj(int objc, Tcl_Obj *CONST objv[]) |
---|
216 | } |
---|
217 | declare 54 generic { |
---|
218 | Tcl_Obj * Tcl_NewLongObj(long longValue) |
---|
219 | } |
---|
220 | declare 55 generic { |
---|
221 | Tcl_Obj * Tcl_NewObj(void) |
---|
222 | } |
---|
223 | declare 56 generic { |
---|
224 | Tcl_Obj *Tcl_NewStringObj(CONST char *bytes, int length) |
---|
225 | } |
---|
226 | declare 57 generic { |
---|
227 | void Tcl_SetBooleanObj(Tcl_Obj *objPtr, int boolValue) |
---|
228 | } |
---|
229 | declare 58 generic { |
---|
230 | unsigned char * Tcl_SetByteArrayLength(Tcl_Obj *objPtr, int length) |
---|
231 | } |
---|
232 | declare 59 generic { |
---|
233 | void Tcl_SetByteArrayObj(Tcl_Obj *objPtr, CONST unsigned char *bytes, |
---|
234 | int length) |
---|
235 | } |
---|
236 | declare 60 generic { |
---|
237 | void Tcl_SetDoubleObj(Tcl_Obj *objPtr, double doubleValue) |
---|
238 | } |
---|
239 | declare 61 generic { |
---|
240 | void Tcl_SetIntObj(Tcl_Obj *objPtr, int intValue) |
---|
241 | } |
---|
242 | declare 62 generic { |
---|
243 | void Tcl_SetListObj(Tcl_Obj *objPtr, int objc, Tcl_Obj *CONST objv[]) |
---|
244 | } |
---|
245 | declare 63 generic { |
---|
246 | void Tcl_SetLongObj(Tcl_Obj *objPtr, long longValue) |
---|
247 | } |
---|
248 | declare 64 generic { |
---|
249 | void Tcl_SetObjLength(Tcl_Obj *objPtr, int length) |
---|
250 | } |
---|
251 | declare 65 generic { |
---|
252 | void Tcl_SetStringObj(Tcl_Obj* objPtr, CONST char* bytes, int length) |
---|
253 | } |
---|
254 | declare 66 generic { |
---|
255 | void Tcl_AddErrorInfo(Tcl_Interp *interp, CONST char *message) |
---|
256 | } |
---|
257 | declare 67 generic { |
---|
258 | void Tcl_AddObjErrorInfo(Tcl_Interp *interp, CONST char *message, |
---|
259 | int length) |
---|
260 | } |
---|
261 | declare 68 generic { |
---|
262 | void Tcl_AllowExceptions(Tcl_Interp *interp) |
---|
263 | } |
---|
264 | declare 69 generic { |
---|
265 | void Tcl_AppendElement(Tcl_Interp *interp, CONST char *element) |
---|
266 | } |
---|
267 | declare 70 generic { |
---|
268 | void Tcl_AppendResult(Tcl_Interp *interp, ...) |
---|
269 | } |
---|
270 | declare 71 generic { |
---|
271 | Tcl_AsyncHandler Tcl_AsyncCreate(Tcl_AsyncProc *proc, |
---|
272 | ClientData clientData) |
---|
273 | } |
---|
274 | declare 72 generic { |
---|
275 | void Tcl_AsyncDelete(Tcl_AsyncHandler async) |
---|
276 | } |
---|
277 | declare 73 generic { |
---|
278 | int Tcl_AsyncInvoke(Tcl_Interp *interp, int code) |
---|
279 | } |
---|
280 | declare 74 generic { |
---|
281 | void Tcl_AsyncMark(Tcl_AsyncHandler async) |
---|
282 | } |
---|
283 | declare 75 generic { |
---|
284 | int Tcl_AsyncReady(void) |
---|
285 | } |
---|
286 | declare 76 generic { |
---|
287 | void Tcl_BackgroundError(Tcl_Interp *interp) |
---|
288 | } |
---|
289 | declare 77 generic { |
---|
290 | char Tcl_Backslash(CONST char *src, int *readPtr) |
---|
291 | } |
---|
292 | declare 78 generic { |
---|
293 | int Tcl_BadChannelOption(Tcl_Interp *interp, CONST char *optionName, |
---|
294 | CONST char *optionList) |
---|
295 | } |
---|
296 | declare 79 generic { |
---|
297 | void Tcl_CallWhenDeleted(Tcl_Interp *interp, Tcl_InterpDeleteProc *proc, |
---|
298 | ClientData clientData) |
---|
299 | } |
---|
300 | declare 80 generic { |
---|
301 | void Tcl_CancelIdleCall(Tcl_IdleProc *idleProc, ClientData clientData) |
---|
302 | } |
---|
303 | declare 81 generic { |
---|
304 | int Tcl_Close(Tcl_Interp *interp, Tcl_Channel chan) |
---|
305 | } |
---|
306 | declare 82 generic { |
---|
307 | int Tcl_CommandComplete(CONST char *cmd) |
---|
308 | } |
---|
309 | declare 83 generic { |
---|
310 | char * Tcl_Concat(int argc, CONST84 char * CONST *argv) |
---|
311 | } |
---|
312 | declare 84 generic { |
---|
313 | int Tcl_ConvertElement(CONST char *src, char *dst, int flags) |
---|
314 | } |
---|
315 | declare 85 generic { |
---|
316 | int Tcl_ConvertCountedElement(CONST char *src, int length, char *dst, |
---|
317 | int flags) |
---|
318 | } |
---|
319 | declare 86 generic { |
---|
320 | int Tcl_CreateAlias(Tcl_Interp *slave, CONST char *slaveCmd, |
---|
321 | Tcl_Interp *target, CONST char *targetCmd, int argc, |
---|
322 | CONST84 char * CONST *argv) |
---|
323 | } |
---|
324 | declare 87 generic { |
---|
325 | int Tcl_CreateAliasObj(Tcl_Interp *slave, CONST char *slaveCmd, |
---|
326 | Tcl_Interp *target, CONST char *targetCmd, int objc, |
---|
327 | Tcl_Obj *CONST objv[]) |
---|
328 | } |
---|
329 | declare 88 generic { |
---|
330 | Tcl_Channel Tcl_CreateChannel(Tcl_ChannelType *typePtr, |
---|
331 | CONST char *chanName, ClientData instanceData, int mask) |
---|
332 | } |
---|
333 | declare 89 generic { |
---|
334 | void Tcl_CreateChannelHandler(Tcl_Channel chan, int mask, |
---|
335 | Tcl_ChannelProc *proc, ClientData clientData) |
---|
336 | } |
---|
337 | declare 90 generic { |
---|
338 | void Tcl_CreateCloseHandler(Tcl_Channel chan, Tcl_CloseProc *proc, |
---|
339 | ClientData clientData) |
---|
340 | } |
---|
341 | declare 91 generic { |
---|
342 | Tcl_Command Tcl_CreateCommand(Tcl_Interp *interp, CONST char *cmdName, |
---|
343 | Tcl_CmdProc *proc, ClientData clientData, |
---|
344 | Tcl_CmdDeleteProc *deleteProc) |
---|
345 | } |
---|
346 | declare 92 generic { |
---|
347 | void Tcl_CreateEventSource(Tcl_EventSetupProc *setupProc, |
---|
348 | Tcl_EventCheckProc *checkProc, ClientData clientData) |
---|
349 | } |
---|
350 | declare 93 generic { |
---|
351 | void Tcl_CreateExitHandler(Tcl_ExitProc *proc, ClientData clientData) |
---|
352 | } |
---|
353 | declare 94 generic { |
---|
354 | Tcl_Interp * Tcl_CreateInterp(void) |
---|
355 | } |
---|
356 | declare 95 generic { |
---|
357 | void Tcl_CreateMathFunc(Tcl_Interp *interp, CONST char *name, |
---|
358 | int numArgs, Tcl_ValueType *argTypes, |
---|
359 | Tcl_MathProc *proc, ClientData clientData) |
---|
360 | } |
---|
361 | declare 96 generic { |
---|
362 | Tcl_Command Tcl_CreateObjCommand(Tcl_Interp *interp, |
---|
363 | CONST char *cmdName, |
---|
364 | Tcl_ObjCmdProc *proc, ClientData clientData, |
---|
365 | Tcl_CmdDeleteProc *deleteProc) |
---|
366 | } |
---|
367 | declare 97 generic { |
---|
368 | Tcl_Interp * Tcl_CreateSlave(Tcl_Interp *interp, CONST char *slaveName, |
---|
369 | int isSafe) |
---|
370 | } |
---|
371 | declare 98 generic { |
---|
372 | Tcl_TimerToken Tcl_CreateTimerHandler(int milliseconds, |
---|
373 | Tcl_TimerProc *proc, ClientData clientData) |
---|
374 | } |
---|
375 | declare 99 generic { |
---|
376 | Tcl_Trace Tcl_CreateTrace(Tcl_Interp *interp, int level, |
---|
377 | Tcl_CmdTraceProc *proc, ClientData clientData) |
---|
378 | } |
---|
379 | declare 100 generic { |
---|
380 | void Tcl_DeleteAssocData(Tcl_Interp *interp, CONST char *name) |
---|
381 | } |
---|
382 | declare 101 generic { |
---|
383 | void Tcl_DeleteChannelHandler(Tcl_Channel chan, Tcl_ChannelProc *proc, |
---|
384 | ClientData clientData) |
---|
385 | } |
---|
386 | declare 102 generic { |
---|
387 | void Tcl_DeleteCloseHandler(Tcl_Channel chan, Tcl_CloseProc *proc, |
---|
388 | ClientData clientData) |
---|
389 | } |
---|
390 | declare 103 generic { |
---|
391 | int Tcl_DeleteCommand(Tcl_Interp *interp, CONST char *cmdName) |
---|
392 | } |
---|
393 | declare 104 generic { |
---|
394 | int Tcl_DeleteCommandFromToken(Tcl_Interp *interp, Tcl_Command command) |
---|
395 | } |
---|
396 | declare 105 generic { |
---|
397 | void Tcl_DeleteEvents(Tcl_EventDeleteProc *proc, ClientData clientData) |
---|
398 | } |
---|
399 | declare 106 generic { |
---|
400 | void Tcl_DeleteEventSource(Tcl_EventSetupProc *setupProc, |
---|
401 | Tcl_EventCheckProc *checkProc, ClientData clientData) |
---|
402 | } |
---|
403 | declare 107 generic { |
---|
404 | void Tcl_DeleteExitHandler(Tcl_ExitProc *proc, ClientData clientData) |
---|
405 | } |
---|
406 | declare 108 generic { |
---|
407 | void Tcl_DeleteHashEntry(Tcl_HashEntry *entryPtr) |
---|
408 | } |
---|
409 | declare 109 generic { |
---|
410 | void Tcl_DeleteHashTable(Tcl_HashTable *tablePtr) |
---|
411 | } |
---|
412 | declare 110 generic { |
---|
413 | void Tcl_DeleteInterp(Tcl_Interp *interp) |
---|
414 | } |
---|
415 | declare 111 {unix win} { |
---|
416 | void Tcl_DetachPids(int numPids, Tcl_Pid *pidPtr) |
---|
417 | } |
---|
418 | declare 112 generic { |
---|
419 | void Tcl_DeleteTimerHandler(Tcl_TimerToken token) |
---|
420 | } |
---|
421 | declare 113 generic { |
---|
422 | void Tcl_DeleteTrace(Tcl_Interp *interp, Tcl_Trace trace) |
---|
423 | } |
---|
424 | declare 114 generic { |
---|
425 | void Tcl_DontCallWhenDeleted(Tcl_Interp *interp, |
---|
426 | Tcl_InterpDeleteProc *proc, ClientData clientData) |
---|
427 | } |
---|
428 | declare 115 generic { |
---|
429 | int Tcl_DoOneEvent(int flags) |
---|
430 | } |
---|
431 | declare 116 generic { |
---|
432 | void Tcl_DoWhenIdle(Tcl_IdleProc *proc, ClientData clientData) |
---|
433 | } |
---|
434 | declare 117 generic { |
---|
435 | char * Tcl_DStringAppend(Tcl_DString *dsPtr, CONST char *bytes, int length) |
---|
436 | } |
---|
437 | declare 118 generic { |
---|
438 | char * Tcl_DStringAppendElement(Tcl_DString *dsPtr, CONST char *element) |
---|
439 | } |
---|
440 | declare 119 generic { |
---|
441 | void Tcl_DStringEndSublist(Tcl_DString *dsPtr) |
---|
442 | } |
---|
443 | declare 120 generic { |
---|
444 | void Tcl_DStringFree(Tcl_DString *dsPtr) |
---|
445 | } |
---|
446 | declare 121 generic { |
---|
447 | void Tcl_DStringGetResult(Tcl_Interp *interp, Tcl_DString *dsPtr) |
---|
448 | } |
---|
449 | declare 122 generic { |
---|
450 | void Tcl_DStringInit(Tcl_DString *dsPtr) |
---|
451 | } |
---|
452 | declare 123 generic { |
---|
453 | void Tcl_DStringResult(Tcl_Interp *interp, Tcl_DString *dsPtr) |
---|
454 | } |
---|
455 | declare 124 generic { |
---|
456 | void Tcl_DStringSetLength(Tcl_DString *dsPtr, int length) |
---|
457 | } |
---|
458 | declare 125 generic { |
---|
459 | void Tcl_DStringStartSublist(Tcl_DString *dsPtr) |
---|
460 | } |
---|
461 | declare 126 generic { |
---|
462 | int Tcl_Eof(Tcl_Channel chan) |
---|
463 | } |
---|
464 | declare 127 generic { |
---|
465 | CONST84_RETURN char * Tcl_ErrnoId(void) |
---|
466 | } |
---|
467 | declare 128 generic { |
---|
468 | CONST84_RETURN char * Tcl_ErrnoMsg(int err) |
---|
469 | } |
---|
470 | declare 129 generic { |
---|
471 | int Tcl_Eval(Tcl_Interp *interp, CONST char *script) |
---|
472 | } |
---|
473 | # This is obsolete, use Tcl_FSEvalFile |
---|
474 | declare 130 generic { |
---|
475 | int Tcl_EvalFile(Tcl_Interp *interp, CONST char *fileName) |
---|
476 | } |
---|
477 | declare 131 generic { |
---|
478 | int Tcl_EvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr) |
---|
479 | } |
---|
480 | declare 132 generic { |
---|
481 | void Tcl_EventuallyFree(ClientData clientData, Tcl_FreeProc *freeProc) |
---|
482 | } |
---|
483 | declare 133 generic { |
---|
484 | void Tcl_Exit(int status) |
---|
485 | } |
---|
486 | declare 134 generic { |
---|
487 | int Tcl_ExposeCommand(Tcl_Interp *interp, CONST char *hiddenCmdToken, |
---|
488 | CONST char *cmdName) |
---|
489 | } |
---|
490 | declare 135 generic { |
---|
491 | int Tcl_ExprBoolean(Tcl_Interp *interp, CONST char *expr, int *ptr) |
---|
492 | } |
---|
493 | declare 136 generic { |
---|
494 | int Tcl_ExprBooleanObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *ptr) |
---|
495 | } |
---|
496 | declare 137 generic { |
---|
497 | int Tcl_ExprDouble(Tcl_Interp *interp, CONST char *expr, double *ptr) |
---|
498 | } |
---|
499 | declare 138 generic { |
---|
500 | int Tcl_ExprDoubleObj(Tcl_Interp *interp, Tcl_Obj *objPtr, double *ptr) |
---|
501 | } |
---|
502 | declare 139 generic { |
---|
503 | int Tcl_ExprLong(Tcl_Interp *interp, CONST char *expr, long *ptr) |
---|
504 | } |
---|
505 | declare 140 generic { |
---|
506 | int Tcl_ExprLongObj(Tcl_Interp *interp, Tcl_Obj *objPtr, long *ptr) |
---|
507 | } |
---|
508 | declare 141 generic { |
---|
509 | int Tcl_ExprObj(Tcl_Interp *interp, Tcl_Obj *objPtr, |
---|
510 | Tcl_Obj **resultPtrPtr) |
---|
511 | } |
---|
512 | declare 142 generic { |
---|
513 | int Tcl_ExprString(Tcl_Interp *interp, CONST char *expr) |
---|
514 | } |
---|
515 | declare 143 generic { |
---|
516 | void Tcl_Finalize(void) |
---|
517 | } |
---|
518 | declare 144 generic { |
---|
519 | void Tcl_FindExecutable(CONST char *argv0) |
---|
520 | } |
---|
521 | declare 145 generic { |
---|
522 | Tcl_HashEntry * Tcl_FirstHashEntry(Tcl_HashTable *tablePtr, |
---|
523 | Tcl_HashSearch *searchPtr) |
---|
524 | } |
---|
525 | declare 146 generic { |
---|
526 | int Tcl_Flush(Tcl_Channel chan) |
---|
527 | } |
---|
528 | declare 147 generic { |
---|
529 | void Tcl_FreeResult(Tcl_Interp *interp) |
---|
530 | } |
---|
531 | declare 148 generic { |
---|
532 | int Tcl_GetAlias(Tcl_Interp *interp, CONST char *slaveCmd, |
---|
533 | Tcl_Interp **targetInterpPtr, CONST84 char **targetCmdPtr, |
---|
534 | int *argcPtr, CONST84 char ***argvPtr) |
---|
535 | } |
---|
536 | declare 149 generic { |
---|
537 | int Tcl_GetAliasObj(Tcl_Interp *interp, CONST char *slaveCmd, |
---|
538 | Tcl_Interp **targetInterpPtr, CONST84 char **targetCmdPtr, |
---|
539 | int *objcPtr, Tcl_Obj ***objv) |
---|
540 | } |
---|
541 | declare 150 generic { |
---|
542 | ClientData Tcl_GetAssocData(Tcl_Interp *interp, CONST char *name, |
---|
543 | Tcl_InterpDeleteProc **procPtr) |
---|
544 | } |
---|
545 | declare 151 generic { |
---|
546 | Tcl_Channel Tcl_GetChannel(Tcl_Interp *interp, CONST char *chanName, |
---|
547 | int *modePtr) |
---|
548 | } |
---|
549 | declare 152 generic { |
---|
550 | int Tcl_GetChannelBufferSize(Tcl_Channel chan) |
---|
551 | } |
---|
552 | declare 153 generic { |
---|
553 | int Tcl_GetChannelHandle(Tcl_Channel chan, int direction, |
---|
554 | ClientData *handlePtr) |
---|
555 | } |
---|
556 | declare 154 generic { |
---|
557 | ClientData Tcl_GetChannelInstanceData(Tcl_Channel chan) |
---|
558 | } |
---|
559 | declare 155 generic { |
---|
560 | int Tcl_GetChannelMode(Tcl_Channel chan) |
---|
561 | } |
---|
562 | declare 156 generic { |
---|
563 | CONST84_RETURN char * Tcl_GetChannelName(Tcl_Channel chan) |
---|
564 | } |
---|
565 | declare 157 generic { |
---|
566 | int Tcl_GetChannelOption(Tcl_Interp *interp, Tcl_Channel chan, |
---|
567 | CONST char *optionName, Tcl_DString *dsPtr) |
---|
568 | } |
---|
569 | declare 158 generic { |
---|
570 | Tcl_ChannelType * Tcl_GetChannelType(Tcl_Channel chan) |
---|
571 | } |
---|
572 | declare 159 generic { |
---|
573 | int Tcl_GetCommandInfo(Tcl_Interp *interp, CONST char *cmdName, |
---|
574 | Tcl_CmdInfo *infoPtr) |
---|
575 | } |
---|
576 | declare 160 generic { |
---|
577 | CONST84_RETURN char * Tcl_GetCommandName(Tcl_Interp *interp, |
---|
578 | Tcl_Command command) |
---|
579 | } |
---|
580 | declare 161 generic { |
---|
581 | int Tcl_GetErrno(void) |
---|
582 | } |
---|
583 | declare 162 generic { |
---|
584 | CONST84_RETURN char * Tcl_GetHostName(void) |
---|
585 | } |
---|
586 | declare 163 generic { |
---|
587 | int Tcl_GetInterpPath(Tcl_Interp *askInterp, Tcl_Interp *slaveInterp) |
---|
588 | } |
---|
589 | declare 164 generic { |
---|
590 | Tcl_Interp * Tcl_GetMaster(Tcl_Interp *interp) |
---|
591 | } |
---|
592 | declare 165 generic { |
---|
593 | CONST char * Tcl_GetNameOfExecutable(void) |
---|
594 | } |
---|
595 | declare 166 generic { |
---|
596 | Tcl_Obj * Tcl_GetObjResult(Tcl_Interp *interp) |
---|
597 | } |
---|
598 | |
---|
599 | # Tcl_GetOpenFile is only available on unix, but it is a part of the old |
---|
600 | # generic interface, so we inlcude it here for compatibility reasons. |
---|
601 | |
---|
602 | declare 167 unix { |
---|
603 | int Tcl_GetOpenFile(Tcl_Interp *interp, CONST char *chanID, int forWriting, |
---|
604 | int checkUsage, ClientData *filePtr) |
---|
605 | } |
---|
606 | # Obsolete. Should now use Tcl_FSGetPathType which is objectified |
---|
607 | # and therefore usually faster. |
---|
608 | declare 168 generic { |
---|
609 | Tcl_PathType Tcl_GetPathType(CONST char *path) |
---|
610 | } |
---|
611 | declare 169 generic { |
---|
612 | int Tcl_Gets(Tcl_Channel chan, Tcl_DString *dsPtr) |
---|
613 | } |
---|
614 | declare 170 generic { |
---|
615 | int Tcl_GetsObj(Tcl_Channel chan, Tcl_Obj *objPtr) |
---|
616 | } |
---|
617 | declare 171 generic { |
---|
618 | int Tcl_GetServiceMode(void) |
---|
619 | } |
---|
620 | declare 172 generic { |
---|
621 | Tcl_Interp * Tcl_GetSlave(Tcl_Interp *interp, CONST char *slaveName) |
---|
622 | } |
---|
623 | declare 173 generic { |
---|
624 | Tcl_Channel Tcl_GetStdChannel(int type) |
---|
625 | } |
---|
626 | declare 174 generic { |
---|
627 | CONST84_RETURN char * Tcl_GetStringResult(Tcl_Interp *interp) |
---|
628 | } |
---|
629 | declare 175 generic { |
---|
630 | CONST84_RETURN char * Tcl_GetVar(Tcl_Interp *interp, CONST char *varName, |
---|
631 | int flags) |
---|
632 | } |
---|
633 | declare 176 generic { |
---|
634 | CONST84_RETURN char * Tcl_GetVar2(Tcl_Interp *interp, CONST char *part1, |
---|
635 | CONST char *part2, int flags) |
---|
636 | } |
---|
637 | declare 177 generic { |
---|
638 | int Tcl_GlobalEval(Tcl_Interp *interp, CONST char *command) |
---|
639 | } |
---|
640 | declare 178 generic { |
---|
641 | int Tcl_GlobalEvalObj(Tcl_Interp *interp, Tcl_Obj *objPtr) |
---|
642 | } |
---|
643 | declare 179 generic { |
---|
644 | int Tcl_HideCommand(Tcl_Interp *interp, CONST char *cmdName, |
---|
645 | CONST char *hiddenCmdToken) |
---|
646 | } |
---|
647 | declare 180 generic { |
---|
648 | int Tcl_Init(Tcl_Interp *interp) |
---|
649 | } |
---|
650 | declare 181 generic { |
---|
651 | void Tcl_InitHashTable(Tcl_HashTable *tablePtr, int keyType) |
---|
652 | } |
---|
653 | declare 182 generic { |
---|
654 | int Tcl_InputBlocked(Tcl_Channel chan) |
---|
655 | } |
---|
656 | declare 183 generic { |
---|
657 | int Tcl_InputBuffered(Tcl_Channel chan) |
---|
658 | } |
---|
659 | declare 184 generic { |
---|
660 | int Tcl_InterpDeleted(Tcl_Interp *interp) |
---|
661 | } |
---|
662 | declare 185 generic { |
---|
663 | int Tcl_IsSafe(Tcl_Interp *interp) |
---|
664 | } |
---|
665 | # Obsolete, use Tcl_FSJoinPath |
---|
666 | declare 186 generic { |
---|
667 | char * Tcl_JoinPath(int argc, CONST84 char * CONST *argv, |
---|
668 | Tcl_DString *resultPtr) |
---|
669 | } |
---|
670 | declare 187 generic { |
---|
671 | int Tcl_LinkVar(Tcl_Interp *interp, CONST char *varName, char *addr, |
---|
672 | int type) |
---|
673 | } |
---|
674 | |
---|
675 | # This slot is reserved for use by the plus patch: |
---|
676 | # declare 188 generic { |
---|
677 | # Tcl_MainLoop |
---|
678 | # } |
---|
679 | |
---|
680 | declare 189 generic { |
---|
681 | Tcl_Channel Tcl_MakeFileChannel(ClientData handle, int mode) |
---|
682 | } |
---|
683 | declare 190 generic { |
---|
684 | int Tcl_MakeSafe(Tcl_Interp *interp) |
---|
685 | } |
---|
686 | declare 191 generic { |
---|
687 | Tcl_Channel Tcl_MakeTcpClientChannel(ClientData tcpSocket) |
---|
688 | } |
---|
689 | declare 192 generic { |
---|
690 | char * Tcl_Merge(int argc, CONST84 char * CONST *argv) |
---|
691 | } |
---|
692 | declare 193 generic { |
---|
693 | Tcl_HashEntry * Tcl_NextHashEntry(Tcl_HashSearch *searchPtr) |
---|
694 | } |
---|
695 | declare 194 generic { |
---|
696 | void Tcl_NotifyChannel(Tcl_Channel channel, int mask) |
---|
697 | } |
---|
698 | declare 195 generic { |
---|
699 | Tcl_Obj * Tcl_ObjGetVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr, |
---|
700 | Tcl_Obj *part2Ptr, int flags) |
---|
701 | } |
---|
702 | declare 196 generic { |
---|
703 | Tcl_Obj * Tcl_ObjSetVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr, |
---|
704 | Tcl_Obj *part2Ptr, Tcl_Obj *newValuePtr, int flags) |
---|
705 | } |
---|
706 | declare 197 {unix win} { |
---|
707 | Tcl_Channel Tcl_OpenCommandChannel(Tcl_Interp *interp, int argc, |
---|
708 | CONST84 char **argv, int flags) |
---|
709 | } |
---|
710 | # This is obsolete, use Tcl_FSOpenFileChannel |
---|
711 | declare 198 generic { |
---|
712 | Tcl_Channel Tcl_OpenFileChannel(Tcl_Interp *interp, CONST char *fileName, |
---|
713 | CONST char *modeString, int permissions) |
---|
714 | } |
---|
715 | declare 199 generic { |
---|
716 | Tcl_Channel Tcl_OpenTcpClient(Tcl_Interp *interp, int port, |
---|
717 | CONST char *address, CONST char *myaddr, int myport, int async) |
---|
718 | } |
---|
719 | declare 200 generic { |
---|
720 | Tcl_Channel Tcl_OpenTcpServer(Tcl_Interp *interp, int port, |
---|
721 | CONST char *host, Tcl_TcpAcceptProc *acceptProc, |
---|
722 | ClientData callbackData) |
---|
723 | } |
---|
724 | declare 201 generic { |
---|
725 | void Tcl_Preserve(ClientData data) |
---|
726 | } |
---|
727 | declare 202 generic { |
---|
728 | void Tcl_PrintDouble(Tcl_Interp *interp, double value, char *dst) |
---|
729 | } |
---|
730 | declare 203 generic { |
---|
731 | int Tcl_PutEnv(CONST char *assignment) |
---|
732 | } |
---|
733 | declare 204 generic { |
---|
734 | CONST84_RETURN char * Tcl_PosixError(Tcl_Interp *interp) |
---|
735 | } |
---|
736 | declare 205 generic { |
---|
737 | void Tcl_QueueEvent(Tcl_Event *evPtr, Tcl_QueuePosition position) |
---|
738 | } |
---|
739 | declare 206 generic { |
---|
740 | int Tcl_Read(Tcl_Channel chan, char *bufPtr, int toRead) |
---|
741 | } |
---|
742 | declare 207 {unix win} { |
---|
743 | void Tcl_ReapDetachedProcs(void) |
---|
744 | } |
---|
745 | declare 208 generic { |
---|
746 | int Tcl_RecordAndEval(Tcl_Interp *interp, CONST char *cmd, int flags) |
---|
747 | } |
---|
748 | declare 209 generic { |
---|
749 | int Tcl_RecordAndEvalObj(Tcl_Interp *interp, Tcl_Obj *cmdPtr, int flags) |
---|
750 | } |
---|
751 | declare 210 generic { |
---|
752 | void Tcl_RegisterChannel(Tcl_Interp *interp, Tcl_Channel chan) |
---|
753 | } |
---|
754 | declare 211 generic { |
---|
755 | void Tcl_RegisterObjType(Tcl_ObjType *typePtr) |
---|
756 | } |
---|
757 | declare 212 generic { |
---|
758 | Tcl_RegExp Tcl_RegExpCompile(Tcl_Interp *interp, CONST char *pattern) |
---|
759 | } |
---|
760 | declare 213 generic { |
---|
761 | int Tcl_RegExpExec(Tcl_Interp *interp, Tcl_RegExp regexp, |
---|
762 | CONST char *text, CONST char *start) |
---|
763 | } |
---|
764 | declare 214 generic { |
---|
765 | int Tcl_RegExpMatch(Tcl_Interp *interp, CONST char *text, |
---|
766 | CONST char *pattern) |
---|
767 | } |
---|
768 | declare 215 generic { |
---|
769 | void Tcl_RegExpRange(Tcl_RegExp regexp, int index, |
---|
770 | CONST84 char **startPtr, CONST84 char **endPtr) |
---|
771 | } |
---|
772 | declare 216 generic { |
---|
773 | void Tcl_Release(ClientData clientData) |
---|
774 | } |
---|
775 | declare 217 generic { |
---|
776 | void Tcl_ResetResult(Tcl_Interp *interp) |
---|
777 | } |
---|
778 | declare 218 generic { |
---|
779 | int Tcl_ScanElement(CONST char *str, int *flagPtr) |
---|
780 | } |
---|
781 | declare 219 generic { |
---|
782 | int Tcl_ScanCountedElement(CONST char *str, int length, int *flagPtr) |
---|
783 | } |
---|
784 | # Obsolete |
---|
785 | declare 220 generic { |
---|
786 | int Tcl_SeekOld(Tcl_Channel chan, int offset, int mode) |
---|
787 | } |
---|
788 | declare 221 generic { |
---|
789 | int Tcl_ServiceAll(void) |
---|
790 | } |
---|
791 | declare 222 generic { |
---|
792 | int Tcl_ServiceEvent(int flags) |
---|
793 | } |
---|
794 | declare 223 generic { |
---|
795 | void Tcl_SetAssocData(Tcl_Interp *interp, CONST char *name, |
---|
796 | Tcl_InterpDeleteProc *proc, ClientData clientData) |
---|
797 | } |
---|
798 | declare 224 generic { |
---|
799 | void Tcl_SetChannelBufferSize(Tcl_Channel chan, int sz) |
---|
800 | } |
---|
801 | declare 225 generic { |
---|
802 | int Tcl_SetChannelOption(Tcl_Interp *interp, Tcl_Channel chan, |
---|
803 | CONST char *optionName, CONST char *newValue) |
---|
804 | } |
---|
805 | declare 226 generic { |
---|
806 | int Tcl_SetCommandInfo(Tcl_Interp *interp, CONST char *cmdName, |
---|
807 | CONST Tcl_CmdInfo *infoPtr) |
---|
808 | } |
---|
809 | declare 227 generic { |
---|
810 | void Tcl_SetErrno(int err) |
---|
811 | } |
---|
812 | declare 228 generic { |
---|
813 | void Tcl_SetErrorCode(Tcl_Interp *interp, ...) |
---|
814 | } |
---|
815 | declare 229 generic { |
---|
816 | void Tcl_SetMaxBlockTime(Tcl_Time *timePtr) |
---|
817 | } |
---|
818 | declare 230 generic { |
---|
819 | void Tcl_SetPanicProc(Tcl_PanicProc *panicProc) |
---|
820 | } |
---|
821 | declare 231 generic { |
---|
822 | int Tcl_SetRecursionLimit(Tcl_Interp *interp, int depth) |
---|
823 | } |
---|
824 | declare 232 generic { |
---|
825 | void Tcl_SetResult(Tcl_Interp *interp, char *result, |
---|
826 | Tcl_FreeProc *freeProc) |
---|
827 | } |
---|
828 | declare 233 generic { |
---|
829 | int Tcl_SetServiceMode(int mode) |
---|
830 | } |
---|
831 | declare 234 generic { |
---|
832 | void Tcl_SetObjErrorCode(Tcl_Interp *interp, Tcl_Obj *errorObjPtr) |
---|
833 | } |
---|
834 | declare 235 generic { |
---|
835 | void Tcl_SetObjResult(Tcl_Interp *interp, Tcl_Obj *resultObjPtr) |
---|
836 | } |
---|
837 | declare 236 generic { |
---|
838 | void Tcl_SetStdChannel(Tcl_Channel channel, int type) |
---|
839 | } |
---|
840 | declare 237 generic { |
---|
841 | CONST84_RETURN char * Tcl_SetVar(Tcl_Interp *interp, CONST char *varName, |
---|
842 | CONST char *newValue, int flags) |
---|
843 | } |
---|
844 | declare 238 generic { |
---|
845 | CONST84_RETURN char * Tcl_SetVar2(Tcl_Interp *interp, CONST char *part1, |
---|
846 | CONST char *part2, CONST char *newValue, int flags) |
---|
847 | } |
---|
848 | declare 239 generic { |
---|
849 | CONST84_RETURN char * Tcl_SignalId(int sig) |
---|
850 | } |
---|
851 | declare 240 generic { |
---|
852 | CONST84_RETURN char * Tcl_SignalMsg(int sig) |
---|
853 | } |
---|
854 | declare 241 generic { |
---|
855 | void Tcl_SourceRCFile(Tcl_Interp *interp) |
---|
856 | } |
---|
857 | declare 242 generic { |
---|
858 | int Tcl_SplitList(Tcl_Interp *interp, CONST char *listStr, int *argcPtr, |
---|
859 | CONST84 char ***argvPtr) |
---|
860 | } |
---|
861 | # Obsolete, use Tcl_FSSplitPath |
---|
862 | declare 243 generic { |
---|
863 | void Tcl_SplitPath(CONST char *path, int *argcPtr, CONST84 char ***argvPtr) |
---|
864 | } |
---|
865 | declare 244 generic { |
---|
866 | void Tcl_StaticPackage(Tcl_Interp *interp, CONST char *pkgName, |
---|
867 | Tcl_PackageInitProc *initProc, Tcl_PackageInitProc *safeInitProc) |
---|
868 | } |
---|
869 | declare 245 generic { |
---|
870 | int Tcl_StringMatch(CONST char *str, CONST char *pattern) |
---|
871 | } |
---|
872 | # Obsolete |
---|
873 | declare 246 generic { |
---|
874 | int Tcl_TellOld(Tcl_Channel chan) |
---|
875 | } |
---|
876 | declare 247 generic { |
---|
877 | int Tcl_TraceVar(Tcl_Interp *interp, CONST char *varName, int flags, |
---|
878 | Tcl_VarTraceProc *proc, ClientData clientData) |
---|
879 | } |
---|
880 | declare 248 generic { |
---|
881 | int Tcl_TraceVar2(Tcl_Interp *interp, CONST char *part1, CONST char *part2, |
---|
882 | int flags, Tcl_VarTraceProc *proc, ClientData clientData) |
---|
883 | } |
---|
884 | declare 249 generic { |
---|
885 | char * Tcl_TranslateFileName(Tcl_Interp *interp, CONST char *name, |
---|
886 | Tcl_DString *bufferPtr) |
---|
887 | } |
---|
888 | declare 250 generic { |
---|
889 | int Tcl_Ungets(Tcl_Channel chan, CONST char *str, int len, int atHead) |
---|
890 | } |
---|
891 | declare 251 generic { |
---|
892 | void Tcl_UnlinkVar(Tcl_Interp *interp, CONST char *varName) |
---|
893 | } |
---|
894 | declare 252 generic { |
---|
895 | int Tcl_UnregisterChannel(Tcl_Interp *interp, Tcl_Channel chan) |
---|
896 | } |
---|
897 | declare 253 generic { |
---|
898 | int Tcl_UnsetVar(Tcl_Interp *interp, CONST char *varName, int flags) |
---|
899 | } |
---|
900 | declare 254 generic { |
---|
901 | int Tcl_UnsetVar2(Tcl_Interp *interp, CONST char *part1, CONST char *part2, |
---|
902 | int flags) |
---|
903 | } |
---|
904 | declare 255 generic { |
---|
905 | void Tcl_UntraceVar(Tcl_Interp *interp, CONST char *varName, int flags, |
---|
906 | Tcl_VarTraceProc *proc, ClientData clientData) |
---|
907 | } |
---|
908 | declare 256 generic { |
---|
909 | void Tcl_UntraceVar2(Tcl_Interp *interp, CONST char *part1, |
---|
910 | CONST char *part2, int flags, Tcl_VarTraceProc *proc, |
---|
911 | ClientData clientData) |
---|
912 | } |
---|
913 | declare 257 generic { |
---|
914 | void Tcl_UpdateLinkedVar(Tcl_Interp *interp, CONST char *varName) |
---|
915 | } |
---|
916 | declare 258 generic { |
---|
917 | int Tcl_UpVar(Tcl_Interp *interp, CONST char *frameName, |
---|
918 | CONST char *varName, CONST char *localName, int flags) |
---|
919 | } |
---|
920 | declare 259 generic { |
---|
921 | int Tcl_UpVar2(Tcl_Interp *interp, CONST char *frameName, CONST char *part1, |
---|
922 | CONST char *part2, CONST char *localName, int flags) |
---|
923 | } |
---|
924 | declare 260 generic { |
---|
925 | int Tcl_VarEval(Tcl_Interp *interp, ...) |
---|
926 | } |
---|
927 | declare 261 generic { |
---|
928 | ClientData Tcl_VarTraceInfo(Tcl_Interp *interp, CONST char *varName, |
---|
929 | int flags, Tcl_VarTraceProc *procPtr, ClientData prevClientData) |
---|
930 | } |
---|
931 | declare 262 generic { |
---|
932 | ClientData Tcl_VarTraceInfo2(Tcl_Interp *interp, CONST char *part1, |
---|
933 | CONST char *part2, int flags, Tcl_VarTraceProc *procPtr, |
---|
934 | ClientData prevClientData) |
---|
935 | } |
---|
936 | declare 263 generic { |
---|
937 | int Tcl_Write(Tcl_Channel chan, CONST char *s, int slen) |
---|
938 | } |
---|
939 | declare 264 generic { |
---|
940 | void Tcl_WrongNumArgs(Tcl_Interp *interp, int objc, |
---|
941 | Tcl_Obj *CONST objv[], CONST char *message) |
---|
942 | } |
---|
943 | declare 265 generic { |
---|
944 | int Tcl_DumpActiveMemory(CONST char *fileName) |
---|
945 | } |
---|
946 | declare 266 generic { |
---|
947 | void Tcl_ValidateAllMemory(CONST char *file, int line) |
---|
948 | } |
---|
949 | declare 267 generic { |
---|
950 | void Tcl_AppendResultVA(Tcl_Interp *interp, va_list argList) |
---|
951 | } |
---|
952 | declare 268 generic { |
---|
953 | void Tcl_AppendStringsToObjVA(Tcl_Obj *objPtr, va_list argList) |
---|
954 | } |
---|
955 | declare 269 generic { |
---|
956 | CONST84_RETURN char * Tcl_HashStats(Tcl_HashTable *tablePtr) |
---|
957 | } |
---|
958 | declare 270 generic { |
---|
959 | CONST84_RETURN char * Tcl_ParseVar(Tcl_Interp *interp, CONST char *start, |
---|
960 | CONST84 char **termPtr) |
---|
961 | } |
---|
962 | declare 271 generic { |
---|
963 | CONST84_RETURN char * Tcl_PkgPresent(Tcl_Interp *interp, CONST char *name, |
---|
964 | CONST char *version, int exact) |
---|
965 | } |
---|
966 | declare 272 generic { |
---|
967 | CONST84_RETURN char * Tcl_PkgPresentEx(Tcl_Interp *interp, |
---|
968 | CONST char *name, CONST char *version, int exact, |
---|
969 | ClientData *clientDataPtr) |
---|
970 | } |
---|
971 | declare 273 generic { |
---|
972 | int Tcl_PkgProvide(Tcl_Interp *interp, CONST char *name, |
---|
973 | CONST char *version) |
---|
974 | } |
---|
975 | # TIP #268: The internally used new Require function is in slot 573. |
---|
976 | declare 274 generic { |
---|
977 | CONST84_RETURN char * Tcl_PkgRequire(Tcl_Interp *interp, CONST char *name, |
---|
978 | CONST char *version, int exact) |
---|
979 | } |
---|
980 | declare 275 generic { |
---|
981 | void Tcl_SetErrorCodeVA(Tcl_Interp *interp, va_list argList) |
---|
982 | } |
---|
983 | declare 276 generic { |
---|
984 | int Tcl_VarEvalVA(Tcl_Interp *interp, va_list argList) |
---|
985 | } |
---|
986 | declare 277 generic { |
---|
987 | Tcl_Pid Tcl_WaitPid(Tcl_Pid pid, int *statPtr, int options) |
---|
988 | } |
---|
989 | declare 278 generic { |
---|
990 | void Tcl_PanicVA(CONST char *format, va_list argList) |
---|
991 | } |
---|
992 | declare 279 generic { |
---|
993 | void Tcl_GetVersion(int *major, int *minor, int *patchLevel, int *type) |
---|
994 | } |
---|
995 | declare 280 generic { |
---|
996 | void Tcl_InitMemory(Tcl_Interp *interp) |
---|
997 | } |
---|
998 | |
---|
999 | # Andreas Kupries <a.kupries@westend.com>, 03/21/1999 |
---|
1000 | # "Trf-Patch for filtering channels" |
---|
1001 | # |
---|
1002 | # C-Level API for (un)stacking of channels. This allows the introduction |
---|
1003 | # of filtering channels with relatively little changes to the core. |
---|
1004 | # This patch was created in cooperation with Jan Nijtmans j.nijtmans@chello.nl |
---|
1005 | # and is therefore part of his plus-patches too. |
---|
1006 | # |
---|
1007 | # It would have been possible to place the following definitions according |
---|
1008 | # to the alphabetical order used elsewhere in this file, but I decided |
---|
1009 | # against that to ease the maintenance of the patch across new tcl versions |
---|
1010 | # (patch usually has no problems to integrate the patch file for the last |
---|
1011 | # version into the new one). |
---|
1012 | |
---|
1013 | declare 281 generic { |
---|
1014 | Tcl_Channel Tcl_StackChannel(Tcl_Interp *interp, Tcl_ChannelType *typePtr, |
---|
1015 | ClientData instanceData, int mask, Tcl_Channel prevChan) |
---|
1016 | } |
---|
1017 | declare 282 generic { |
---|
1018 | int Tcl_UnstackChannel(Tcl_Interp *interp, Tcl_Channel chan) |
---|
1019 | } |
---|
1020 | declare 283 generic { |
---|
1021 | Tcl_Channel Tcl_GetStackedChannel(Tcl_Channel chan) |
---|
1022 | } |
---|
1023 | |
---|
1024 | # 284 was reserved, but added in 8.4a2 |
---|
1025 | declare 284 generic { |
---|
1026 | void Tcl_SetMainLoop(Tcl_MainLoopProc *proc) |
---|
1027 | } |
---|
1028 | |
---|
1029 | # Reserved for future use (8.0.x vs. 8.1) |
---|
1030 | # declare 285 generic { |
---|
1031 | # } |
---|
1032 | |
---|
1033 | |
---|
1034 | # Added in 8.1: |
---|
1035 | |
---|
1036 | declare 286 generic { |
---|
1037 | void Tcl_AppendObjToObj(Tcl_Obj *objPtr, Tcl_Obj *appendObjPtr) |
---|
1038 | } |
---|
1039 | declare 287 generic { |
---|
1040 | Tcl_Encoding Tcl_CreateEncoding(const Tcl_EncodingType *typePtr) |
---|
1041 | } |
---|
1042 | declare 288 generic { |
---|
1043 | void Tcl_CreateThreadExitHandler(Tcl_ExitProc *proc, ClientData clientData) |
---|
1044 | } |
---|
1045 | declare 289 generic { |
---|
1046 | void Tcl_DeleteThreadExitHandler(Tcl_ExitProc *proc, ClientData clientData) |
---|
1047 | } |
---|
1048 | declare 290 generic { |
---|
1049 | void Tcl_DiscardResult(Tcl_SavedResult *statePtr) |
---|
1050 | } |
---|
1051 | declare 291 generic { |
---|
1052 | int Tcl_EvalEx(Tcl_Interp *interp, CONST char *script, int numBytes, |
---|
1053 | int flags) |
---|
1054 | } |
---|
1055 | declare 292 generic { |
---|
1056 | int Tcl_EvalObjv(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], |
---|
1057 | int flags) |
---|
1058 | } |
---|
1059 | declare 293 generic { |
---|
1060 | int Tcl_EvalObjEx(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags) |
---|
1061 | } |
---|
1062 | declare 294 generic { |
---|
1063 | void Tcl_ExitThread(int status) |
---|
1064 | } |
---|
1065 | declare 295 generic { |
---|
1066 | int Tcl_ExternalToUtf(Tcl_Interp *interp, Tcl_Encoding encoding, |
---|
1067 | CONST char *src, int srcLen, int flags, |
---|
1068 | Tcl_EncodingState *statePtr, char *dst, int dstLen, |
---|
1069 | int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr) |
---|
1070 | } |
---|
1071 | declare 296 generic { |
---|
1072 | char * Tcl_ExternalToUtfDString(Tcl_Encoding encoding, |
---|
1073 | CONST char *src, int srcLen, Tcl_DString *dsPtr) |
---|
1074 | } |
---|
1075 | declare 297 generic { |
---|
1076 | void Tcl_FinalizeThread(void) |
---|
1077 | } |
---|
1078 | declare 298 generic { |
---|
1079 | void Tcl_FinalizeNotifier(ClientData clientData) |
---|
1080 | } |
---|
1081 | declare 299 generic { |
---|
1082 | void Tcl_FreeEncoding(Tcl_Encoding encoding) |
---|
1083 | } |
---|
1084 | declare 300 generic { |
---|
1085 | Tcl_ThreadId Tcl_GetCurrentThread(void) |
---|
1086 | } |
---|
1087 | declare 301 generic { |
---|
1088 | Tcl_Encoding Tcl_GetEncoding(Tcl_Interp *interp, CONST char *name) |
---|
1089 | } |
---|
1090 | declare 302 generic { |
---|
1091 | CONST84_RETURN char * Tcl_GetEncodingName(Tcl_Encoding encoding) |
---|
1092 | } |
---|
1093 | declare 303 generic { |
---|
1094 | void Tcl_GetEncodingNames(Tcl_Interp *interp) |
---|
1095 | } |
---|
1096 | declare 304 generic { |
---|
1097 | int Tcl_GetIndexFromObjStruct(Tcl_Interp *interp, Tcl_Obj *objPtr, |
---|
1098 | CONST VOID *tablePtr, int offset, CONST char *msg, int flags, |
---|
1099 | int *indexPtr) |
---|
1100 | } |
---|
1101 | declare 305 generic { |
---|
1102 | VOID * Tcl_GetThreadData(Tcl_ThreadDataKey *keyPtr, int size) |
---|
1103 | } |
---|
1104 | declare 306 generic { |
---|
1105 | Tcl_Obj * Tcl_GetVar2Ex(Tcl_Interp *interp, CONST char *part1, |
---|
1106 | CONST char *part2, int flags) |
---|
1107 | } |
---|
1108 | declare 307 generic { |
---|
1109 | ClientData Tcl_InitNotifier(void) |
---|
1110 | } |
---|
1111 | declare 308 generic { |
---|
1112 | void Tcl_MutexLock(Tcl_Mutex *mutexPtr) |
---|
1113 | } |
---|
1114 | declare 309 generic { |
---|
1115 | void Tcl_MutexUnlock(Tcl_Mutex *mutexPtr) |
---|
1116 | } |
---|
1117 | declare 310 generic { |
---|
1118 | void Tcl_ConditionNotify(Tcl_Condition *condPtr) |
---|
1119 | } |
---|
1120 | declare 311 generic { |
---|
1121 | void Tcl_ConditionWait(Tcl_Condition *condPtr, Tcl_Mutex *mutexPtr, |
---|
1122 | Tcl_Time *timePtr) |
---|
1123 | } |
---|
1124 | declare 312 generic { |
---|
1125 | int Tcl_NumUtfChars(CONST char *src, int length) |
---|
1126 | } |
---|
1127 | declare 313 generic { |
---|
1128 | int Tcl_ReadChars(Tcl_Channel channel, Tcl_Obj *objPtr, int charsToRead, |
---|
1129 | int appendFlag) |
---|
1130 | } |
---|
1131 | declare 314 generic { |
---|
1132 | void Tcl_RestoreResult(Tcl_Interp *interp, Tcl_SavedResult *statePtr) |
---|
1133 | } |
---|
1134 | declare 315 generic { |
---|
1135 | void Tcl_SaveResult(Tcl_Interp *interp, Tcl_SavedResult *statePtr) |
---|
1136 | } |
---|
1137 | declare 316 generic { |
---|
1138 | int Tcl_SetSystemEncoding(Tcl_Interp *interp, CONST char *name) |
---|
1139 | } |
---|
1140 | declare 317 generic { |
---|
1141 | Tcl_Obj * Tcl_SetVar2Ex(Tcl_Interp *interp, CONST char *part1, |
---|
1142 | CONST char *part2, Tcl_Obj *newValuePtr, int flags) |
---|
1143 | } |
---|
1144 | declare 318 generic { |
---|
1145 | void Tcl_ThreadAlert(Tcl_ThreadId threadId) |
---|
1146 | } |
---|
1147 | declare 319 generic { |
---|
1148 | void Tcl_ThreadQueueEvent(Tcl_ThreadId threadId, Tcl_Event* evPtr, |
---|
1149 | Tcl_QueuePosition position) |
---|
1150 | } |
---|
1151 | declare 320 generic { |
---|
1152 | Tcl_UniChar Tcl_UniCharAtIndex(CONST char *src, int index) |
---|
1153 | } |
---|
1154 | declare 321 generic { |
---|
1155 | Tcl_UniChar Tcl_UniCharToLower(int ch) |
---|
1156 | } |
---|
1157 | declare 322 generic { |
---|
1158 | Tcl_UniChar Tcl_UniCharToTitle(int ch) |
---|
1159 | } |
---|
1160 | declare 323 generic { |
---|
1161 | Tcl_UniChar Tcl_UniCharToUpper(int ch) |
---|
1162 | } |
---|
1163 | declare 324 generic { |
---|
1164 | int Tcl_UniCharToUtf(int ch, char *buf) |
---|
1165 | } |
---|
1166 | declare 325 generic { |
---|
1167 | CONST84_RETURN char * Tcl_UtfAtIndex(CONST char *src, int index) |
---|
1168 | } |
---|
1169 | declare 326 generic { |
---|
1170 | int Tcl_UtfCharComplete(CONST char *src, int length) |
---|
1171 | } |
---|
1172 | declare 327 generic { |
---|
1173 | int Tcl_UtfBackslash(CONST char *src, int *readPtr, char *dst) |
---|
1174 | } |
---|
1175 | declare 328 generic { |
---|
1176 | CONST84_RETURN char * Tcl_UtfFindFirst(CONST char *src, int ch) |
---|
1177 | } |
---|
1178 | declare 329 generic { |
---|
1179 | CONST84_RETURN char * Tcl_UtfFindLast(CONST char *src, int ch) |
---|
1180 | } |
---|
1181 | declare 330 generic { |
---|
1182 | CONST84_RETURN char * Tcl_UtfNext(CONST char *src) |
---|
1183 | } |
---|
1184 | declare 331 generic { |
---|
1185 | CONST84_RETURN char * Tcl_UtfPrev(CONST char *src, CONST char *start) |
---|
1186 | } |
---|
1187 | declare 332 generic { |
---|
1188 | int Tcl_UtfToExternal(Tcl_Interp *interp, Tcl_Encoding encoding, |
---|
1189 | CONST char *src, int srcLen, int flags, |
---|
1190 | Tcl_EncodingState *statePtr, char *dst, int dstLen, |
---|
1191 | int *srcReadPtr, int *dstWrotePtr, int *dstCharsPtr) |
---|
1192 | } |
---|
1193 | declare 333 generic { |
---|
1194 | char * Tcl_UtfToExternalDString(Tcl_Encoding encoding, |
---|
1195 | CONST char *src, int srcLen, Tcl_DString *dsPtr) |
---|
1196 | } |
---|
1197 | declare 334 generic { |
---|
1198 | int Tcl_UtfToLower(char *src) |
---|
1199 | } |
---|
1200 | declare 335 generic { |
---|
1201 | int Tcl_UtfToTitle(char *src) |
---|
1202 | } |
---|
1203 | declare 336 generic { |
---|
1204 | int Tcl_UtfToUniChar(CONST char *src, Tcl_UniChar *chPtr) |
---|
1205 | } |
---|
1206 | declare 337 generic { |
---|
1207 | int Tcl_UtfToUpper(char *src) |
---|
1208 | } |
---|
1209 | declare 338 generic { |
---|
1210 | int Tcl_WriteChars(Tcl_Channel chan, CONST char *src, int srcLen) |
---|
1211 | } |
---|
1212 | declare 339 generic { |
---|
1213 | int Tcl_WriteObj(Tcl_Channel chan, Tcl_Obj *objPtr) |
---|
1214 | } |
---|
1215 | declare 340 generic { |
---|
1216 | char * Tcl_GetString(Tcl_Obj *objPtr) |
---|
1217 | } |
---|
1218 | declare 341 generic { |
---|
1219 | CONST84_RETURN char * Tcl_GetDefaultEncodingDir(void) |
---|
1220 | } |
---|
1221 | declare 342 generic { |
---|
1222 | void Tcl_SetDefaultEncodingDir(CONST char *path) |
---|
1223 | } |
---|
1224 | declare 343 generic { |
---|
1225 | void Tcl_AlertNotifier(ClientData clientData) |
---|
1226 | } |
---|
1227 | declare 344 generic { |
---|
1228 | void Tcl_ServiceModeHook(int mode) |
---|
1229 | } |
---|
1230 | declare 345 generic { |
---|
1231 | int Tcl_UniCharIsAlnum(int ch) |
---|
1232 | } |
---|
1233 | declare 346 generic { |
---|
1234 | int Tcl_UniCharIsAlpha(int ch) |
---|
1235 | } |
---|
1236 | declare 347 generic { |
---|
1237 | int Tcl_UniCharIsDigit(int ch) |
---|
1238 | } |
---|
1239 | declare 348 generic { |
---|
1240 | int Tcl_UniCharIsLower(int ch) |
---|
1241 | } |
---|
1242 | declare 349 generic { |
---|
1243 | int Tcl_UniCharIsSpace(int ch) |
---|
1244 | } |
---|
1245 | declare 350 generic { |
---|
1246 | int Tcl_UniCharIsUpper(int ch) |
---|
1247 | } |
---|
1248 | declare 351 generic { |
---|
1249 | int Tcl_UniCharIsWordChar(int ch) |
---|
1250 | } |
---|
1251 | declare 352 generic { |
---|
1252 | int Tcl_UniCharLen(CONST Tcl_UniChar *uniStr) |
---|
1253 | } |
---|
1254 | declare 353 generic { |
---|
1255 | int Tcl_UniCharNcmp(CONST Tcl_UniChar *ucs, CONST Tcl_UniChar *uct, |
---|
1256 | unsigned long numChars) |
---|
1257 | } |
---|
1258 | declare 354 generic { |
---|
1259 | char * Tcl_UniCharToUtfDString(CONST Tcl_UniChar *uniStr, |
---|
1260 | int uniLength, Tcl_DString *dsPtr) |
---|
1261 | } |
---|
1262 | declare 355 generic { |
---|
1263 | Tcl_UniChar * Tcl_UtfToUniCharDString(CONST char *src, |
---|
1264 | int length, Tcl_DString *dsPtr) |
---|
1265 | } |
---|
1266 | declare 356 generic { |
---|
1267 | Tcl_RegExp Tcl_GetRegExpFromObj(Tcl_Interp *interp, Tcl_Obj *patObj, |
---|
1268 | int flags) |
---|
1269 | } |
---|
1270 | declare 357 generic { |
---|
1271 | Tcl_Obj *Tcl_EvalTokens(Tcl_Interp *interp, Tcl_Token *tokenPtr, |
---|
1272 | int count) |
---|
1273 | } |
---|
1274 | declare 358 generic { |
---|
1275 | void Tcl_FreeParse(Tcl_Parse *parsePtr) |
---|
1276 | } |
---|
1277 | declare 359 generic { |
---|
1278 | void Tcl_LogCommandInfo(Tcl_Interp *interp, CONST char *script, |
---|
1279 | CONST char *command, int length) |
---|
1280 | } |
---|
1281 | declare 360 generic { |
---|
1282 | int Tcl_ParseBraces(Tcl_Interp *interp, CONST char *start, int numBytes, |
---|
1283 | Tcl_Parse *parsePtr, int append, CONST84 char **termPtr) |
---|
1284 | } |
---|
1285 | declare 361 generic { |
---|
1286 | int Tcl_ParseCommand(Tcl_Interp *interp, CONST char *start, int numBytes, |
---|
1287 | int nested, Tcl_Parse *parsePtr) |
---|
1288 | } |
---|
1289 | declare 362 generic { |
---|
1290 | int Tcl_ParseExpr(Tcl_Interp *interp, CONST char *start, int numBytes, |
---|
1291 | Tcl_Parse *parsePtr) |
---|
1292 | } |
---|
1293 | declare 363 generic { |
---|
1294 | int Tcl_ParseQuotedString(Tcl_Interp *interp, CONST char *start, |
---|
1295 | int numBytes, Tcl_Parse *parsePtr, int append, |
---|
1296 | CONST84 char **termPtr) |
---|
1297 | } |
---|
1298 | declare 364 generic { |
---|
1299 | int Tcl_ParseVarName(Tcl_Interp *interp, CONST char *start, int numBytes, |
---|
1300 | Tcl_Parse *parsePtr, int append) |
---|
1301 | } |
---|
1302 | # These 4 functions are obsolete, use Tcl_FSGetCwd, Tcl_FSChdir, |
---|
1303 | # Tcl_FSAccess and Tcl_FSStat |
---|
1304 | declare 365 generic { |
---|
1305 | char *Tcl_GetCwd(Tcl_Interp *interp, Tcl_DString *cwdPtr) |
---|
1306 | } |
---|
1307 | declare 366 generic { |
---|
1308 | int Tcl_Chdir(CONST char *dirName) |
---|
1309 | } |
---|
1310 | declare 367 generic { |
---|
1311 | int Tcl_Access(CONST char *path, int mode) |
---|
1312 | } |
---|
1313 | declare 368 generic { |
---|
1314 | int Tcl_Stat(CONST char *path, struct stat *bufPtr) |
---|
1315 | } |
---|
1316 | declare 369 generic { |
---|
1317 | int Tcl_UtfNcmp(CONST char *s1, CONST char *s2, unsigned long n) |
---|
1318 | } |
---|
1319 | declare 370 generic { |
---|
1320 | int Tcl_UtfNcasecmp(CONST char *s1, CONST char *s2, unsigned long n) |
---|
1321 | } |
---|
1322 | declare 371 generic { |
---|
1323 | int Tcl_StringCaseMatch(CONST char *str, CONST char *pattern, int nocase) |
---|
1324 | } |
---|
1325 | declare 372 generic { |
---|
1326 | int Tcl_UniCharIsControl(int ch) |
---|
1327 | } |
---|
1328 | declare 373 generic { |
---|
1329 | int Tcl_UniCharIsGraph(int ch) |
---|
1330 | } |
---|
1331 | declare 374 generic { |
---|
1332 | int Tcl_UniCharIsPrint(int ch) |
---|
1333 | } |
---|
1334 | declare 375 generic { |
---|
1335 | int Tcl_UniCharIsPunct(int ch) |
---|
1336 | } |
---|
1337 | declare 376 generic { |
---|
1338 | int Tcl_RegExpExecObj(Tcl_Interp *interp, Tcl_RegExp regexp, |
---|
1339 | Tcl_Obj *textObj, int offset, int nmatches, int flags) |
---|
1340 | } |
---|
1341 | declare 377 generic { |
---|
1342 | void Tcl_RegExpGetInfo(Tcl_RegExp regexp, Tcl_RegExpInfo *infoPtr) |
---|
1343 | } |
---|
1344 | declare 378 generic { |
---|
1345 | Tcl_Obj * Tcl_NewUnicodeObj(CONST Tcl_UniChar *unicode, int numChars) |
---|
1346 | } |
---|
1347 | declare 379 generic { |
---|
1348 | void Tcl_SetUnicodeObj(Tcl_Obj *objPtr, CONST Tcl_UniChar *unicode, |
---|
1349 | int numChars) |
---|
1350 | } |
---|
1351 | declare 380 generic { |
---|
1352 | int Tcl_GetCharLength(Tcl_Obj *objPtr) |
---|
1353 | } |
---|
1354 | declare 381 generic { |
---|
1355 | Tcl_UniChar Tcl_GetUniChar(Tcl_Obj *objPtr, int index) |
---|
1356 | } |
---|
1357 | declare 382 generic { |
---|
1358 | Tcl_UniChar * Tcl_GetUnicode(Tcl_Obj *objPtr) |
---|
1359 | } |
---|
1360 | declare 383 generic { |
---|
1361 | Tcl_Obj * Tcl_GetRange(Tcl_Obj *objPtr, int first, int last) |
---|
1362 | } |
---|
1363 | declare 384 generic { |
---|
1364 | void Tcl_AppendUnicodeToObj(Tcl_Obj *objPtr, CONST Tcl_UniChar *unicode, |
---|
1365 | int length) |
---|
1366 | } |
---|
1367 | declare 385 generic { |
---|
1368 | int Tcl_RegExpMatchObj(Tcl_Interp *interp, Tcl_Obj *textObj, |
---|
1369 | Tcl_Obj *patternObj) |
---|
1370 | } |
---|
1371 | declare 386 generic { |
---|
1372 | void Tcl_SetNotifier(Tcl_NotifierProcs *notifierProcPtr) |
---|
1373 | } |
---|
1374 | declare 387 generic { |
---|
1375 | Tcl_Mutex * Tcl_GetAllocMutex(void) |
---|
1376 | } |
---|
1377 | declare 388 generic { |
---|
1378 | int Tcl_GetChannelNames(Tcl_Interp *interp) |
---|
1379 | } |
---|
1380 | declare 389 generic { |
---|
1381 | int Tcl_GetChannelNamesEx(Tcl_Interp *interp, CONST char *pattern) |
---|
1382 | } |
---|
1383 | declare 390 generic { |
---|
1384 | int Tcl_ProcObjCmd(ClientData clientData, Tcl_Interp *interp, |
---|
1385 | int objc, Tcl_Obj *CONST objv[]) |
---|
1386 | } |
---|
1387 | declare 391 generic { |
---|
1388 | void Tcl_ConditionFinalize(Tcl_Condition *condPtr) |
---|
1389 | } |
---|
1390 | declare 392 generic { |
---|
1391 | void Tcl_MutexFinalize(Tcl_Mutex *mutex) |
---|
1392 | } |
---|
1393 | declare 393 generic { |
---|
1394 | int Tcl_CreateThread(Tcl_ThreadId *idPtr, Tcl_ThreadCreateProc proc, |
---|
1395 | ClientData clientData, int stackSize, int flags) |
---|
1396 | } |
---|
1397 | |
---|
1398 | # Introduced in 8.3.2 |
---|
1399 | declare 394 generic { |
---|
1400 | int Tcl_ReadRaw(Tcl_Channel chan, char *dst, int bytesToRead) |
---|
1401 | } |
---|
1402 | declare 395 generic { |
---|
1403 | int Tcl_WriteRaw(Tcl_Channel chan, CONST char *src, int srcLen) |
---|
1404 | } |
---|
1405 | declare 396 generic { |
---|
1406 | Tcl_Channel Tcl_GetTopChannel(Tcl_Channel chan) |
---|
1407 | } |
---|
1408 | declare 397 generic { |
---|
1409 | int Tcl_ChannelBuffered(Tcl_Channel chan) |
---|
1410 | } |
---|
1411 | declare 398 generic { |
---|
1412 | CONST84_RETURN char * Tcl_ChannelName(CONST Tcl_ChannelType *chanTypePtr) |
---|
1413 | } |
---|
1414 | declare 399 generic { |
---|
1415 | Tcl_ChannelTypeVersion Tcl_ChannelVersion( |
---|
1416 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1417 | } |
---|
1418 | declare 400 generic { |
---|
1419 | Tcl_DriverBlockModeProc * Tcl_ChannelBlockModeProc( |
---|
1420 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1421 | } |
---|
1422 | declare 401 generic { |
---|
1423 | Tcl_DriverCloseProc * Tcl_ChannelCloseProc( |
---|
1424 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1425 | } |
---|
1426 | declare 402 generic { |
---|
1427 | Tcl_DriverClose2Proc * Tcl_ChannelClose2Proc( |
---|
1428 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1429 | } |
---|
1430 | declare 403 generic { |
---|
1431 | Tcl_DriverInputProc * Tcl_ChannelInputProc( |
---|
1432 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1433 | } |
---|
1434 | declare 404 generic { |
---|
1435 | Tcl_DriverOutputProc * Tcl_ChannelOutputProc( |
---|
1436 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1437 | } |
---|
1438 | declare 405 generic { |
---|
1439 | Tcl_DriverSeekProc * Tcl_ChannelSeekProc( |
---|
1440 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1441 | } |
---|
1442 | declare 406 generic { |
---|
1443 | Tcl_DriverSetOptionProc * Tcl_ChannelSetOptionProc( |
---|
1444 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1445 | } |
---|
1446 | declare 407 generic { |
---|
1447 | Tcl_DriverGetOptionProc * Tcl_ChannelGetOptionProc( |
---|
1448 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1449 | } |
---|
1450 | declare 408 generic { |
---|
1451 | Tcl_DriverWatchProc * Tcl_ChannelWatchProc( |
---|
1452 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1453 | } |
---|
1454 | declare 409 generic { |
---|
1455 | Tcl_DriverGetHandleProc * Tcl_ChannelGetHandleProc( |
---|
1456 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1457 | } |
---|
1458 | declare 410 generic { |
---|
1459 | Tcl_DriverFlushProc * Tcl_ChannelFlushProc( |
---|
1460 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1461 | } |
---|
1462 | declare 411 generic { |
---|
1463 | Tcl_DriverHandlerProc * Tcl_ChannelHandlerProc( |
---|
1464 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1465 | } |
---|
1466 | |
---|
1467 | # Introduced in 8.4a2 |
---|
1468 | declare 412 generic { |
---|
1469 | int Tcl_JoinThread(Tcl_ThreadId threadId, int* result) |
---|
1470 | } |
---|
1471 | declare 413 generic { |
---|
1472 | int Tcl_IsChannelShared(Tcl_Channel channel) |
---|
1473 | } |
---|
1474 | declare 414 generic { |
---|
1475 | int Tcl_IsChannelRegistered(Tcl_Interp* interp, Tcl_Channel channel) |
---|
1476 | } |
---|
1477 | declare 415 generic { |
---|
1478 | void Tcl_CutChannel(Tcl_Channel channel) |
---|
1479 | } |
---|
1480 | declare 416 generic { |
---|
1481 | void Tcl_SpliceChannel(Tcl_Channel channel) |
---|
1482 | } |
---|
1483 | declare 417 generic { |
---|
1484 | void Tcl_ClearChannelHandlers(Tcl_Channel channel) |
---|
1485 | } |
---|
1486 | declare 418 generic { |
---|
1487 | int Tcl_IsChannelExisting(CONST char* channelName) |
---|
1488 | } |
---|
1489 | declare 419 generic { |
---|
1490 | int Tcl_UniCharNcasecmp(CONST Tcl_UniChar *ucs, CONST Tcl_UniChar *uct, |
---|
1491 | unsigned long numChars) |
---|
1492 | } |
---|
1493 | declare 420 generic { |
---|
1494 | int Tcl_UniCharCaseMatch(CONST Tcl_UniChar *uniStr, |
---|
1495 | CONST Tcl_UniChar *uniPattern, int nocase) |
---|
1496 | } |
---|
1497 | declare 421 generic { |
---|
1498 | Tcl_HashEntry *Tcl_FindHashEntry(Tcl_HashTable *tablePtr, CONST char *key) |
---|
1499 | } |
---|
1500 | declare 422 generic { |
---|
1501 | Tcl_HashEntry *Tcl_CreateHashEntry(Tcl_HashTable *tablePtr, |
---|
1502 | CONST char *key, int *newPtr) |
---|
1503 | } |
---|
1504 | declare 423 generic { |
---|
1505 | void Tcl_InitCustomHashTable(Tcl_HashTable *tablePtr, int keyType, |
---|
1506 | Tcl_HashKeyType *typePtr) |
---|
1507 | } |
---|
1508 | declare 424 generic { |
---|
1509 | void Tcl_InitObjHashTable(Tcl_HashTable *tablePtr) |
---|
1510 | } |
---|
1511 | declare 425 generic { |
---|
1512 | ClientData Tcl_CommandTraceInfo(Tcl_Interp *interp, CONST char *varName, |
---|
1513 | int flags, Tcl_CommandTraceProc *procPtr, |
---|
1514 | ClientData prevClientData) |
---|
1515 | } |
---|
1516 | declare 426 generic { |
---|
1517 | int Tcl_TraceCommand(Tcl_Interp *interp, CONST char *varName, int flags, |
---|
1518 | Tcl_CommandTraceProc *proc, ClientData clientData) |
---|
1519 | } |
---|
1520 | declare 427 generic { |
---|
1521 | void Tcl_UntraceCommand(Tcl_Interp *interp, CONST char *varName, |
---|
1522 | int flags, Tcl_CommandTraceProc *proc, ClientData clientData) |
---|
1523 | } |
---|
1524 | declare 428 generic { |
---|
1525 | char * Tcl_AttemptAlloc(unsigned int size) |
---|
1526 | } |
---|
1527 | declare 429 generic { |
---|
1528 | char * Tcl_AttemptDbCkalloc(unsigned int size, CONST char *file, int line) |
---|
1529 | } |
---|
1530 | declare 430 generic { |
---|
1531 | char * Tcl_AttemptRealloc(char *ptr, unsigned int size) |
---|
1532 | } |
---|
1533 | declare 431 generic { |
---|
1534 | char * Tcl_AttemptDbCkrealloc(char *ptr, unsigned int size, |
---|
1535 | CONST char *file, int line) |
---|
1536 | } |
---|
1537 | declare 432 generic { |
---|
1538 | int Tcl_AttemptSetObjLength(Tcl_Obj *objPtr, int length) |
---|
1539 | } |
---|
1540 | declare 433 generic { |
---|
1541 | Tcl_ThreadId Tcl_GetChannelThread(Tcl_Channel channel) |
---|
1542 | } |
---|
1543 | # introduced in 8.4a3 |
---|
1544 | declare 434 generic { |
---|
1545 | Tcl_UniChar * Tcl_GetUnicodeFromObj(Tcl_Obj *objPtr, int *lengthPtr) |
---|
1546 | } |
---|
1547 | declare 435 generic { |
---|
1548 | int Tcl_GetMathFuncInfo(Tcl_Interp *interp, CONST char *name, |
---|
1549 | int *numArgsPtr, Tcl_ValueType **argTypesPtr, |
---|
1550 | Tcl_MathProc **procPtr, ClientData *clientDataPtr) |
---|
1551 | } |
---|
1552 | declare 436 generic { |
---|
1553 | Tcl_Obj * Tcl_ListMathFuncs(Tcl_Interp *interp, CONST char *pattern) |
---|
1554 | } |
---|
1555 | declare 437 generic { |
---|
1556 | Tcl_Obj * Tcl_SubstObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int flags) |
---|
1557 | } |
---|
1558 | declare 438 generic { |
---|
1559 | int Tcl_DetachChannel(Tcl_Interp* interp, Tcl_Channel channel) |
---|
1560 | } |
---|
1561 | declare 439 generic { |
---|
1562 | int Tcl_IsStandardChannel(Tcl_Channel channel) |
---|
1563 | } |
---|
1564 | # New functions due to TIP#17 |
---|
1565 | declare 440 generic { |
---|
1566 | int Tcl_FSCopyFile(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr) |
---|
1567 | } |
---|
1568 | declare 441 generic { |
---|
1569 | int Tcl_FSCopyDirectory(Tcl_Obj *srcPathPtr, |
---|
1570 | Tcl_Obj *destPathPtr, Tcl_Obj **errorPtr) |
---|
1571 | } |
---|
1572 | declare 442 generic { |
---|
1573 | int Tcl_FSCreateDirectory(Tcl_Obj *pathPtr) |
---|
1574 | } |
---|
1575 | declare 443 generic { |
---|
1576 | int Tcl_FSDeleteFile(Tcl_Obj *pathPtr) |
---|
1577 | } |
---|
1578 | declare 444 generic { |
---|
1579 | int Tcl_FSLoadFile(Tcl_Interp * interp, |
---|
1580 | Tcl_Obj *pathPtr, CONST char * sym1, CONST char * sym2, |
---|
1581 | Tcl_PackageInitProc ** proc1Ptr, |
---|
1582 | Tcl_PackageInitProc ** proc2Ptr, |
---|
1583 | Tcl_LoadHandle * handlePtr, |
---|
1584 | Tcl_FSUnloadFileProc **unloadProcPtr) |
---|
1585 | } |
---|
1586 | declare 445 generic { |
---|
1587 | int Tcl_FSMatchInDirectory(Tcl_Interp *interp, Tcl_Obj *result, |
---|
1588 | Tcl_Obj *pathPtr, CONST char *pattern, Tcl_GlobTypeData *types) |
---|
1589 | } |
---|
1590 | declare 446 generic { |
---|
1591 | Tcl_Obj * Tcl_FSLink(Tcl_Obj *pathPtr, Tcl_Obj *toPtr, int linkAction) |
---|
1592 | } |
---|
1593 | declare 447 generic { |
---|
1594 | int Tcl_FSRemoveDirectory(Tcl_Obj *pathPtr, |
---|
1595 | int recursive, Tcl_Obj **errorPtr) |
---|
1596 | } |
---|
1597 | declare 448 generic { |
---|
1598 | int Tcl_FSRenameFile(Tcl_Obj *srcPathPtr, Tcl_Obj *destPathPtr) |
---|
1599 | } |
---|
1600 | declare 449 generic { |
---|
1601 | int Tcl_FSLstat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf) |
---|
1602 | } |
---|
1603 | declare 450 generic { |
---|
1604 | int Tcl_FSUtime(Tcl_Obj *pathPtr, struct utimbuf *tval) |
---|
1605 | } |
---|
1606 | declare 451 generic { |
---|
1607 | int Tcl_FSFileAttrsGet(Tcl_Interp *interp, |
---|
1608 | int index, Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef) |
---|
1609 | } |
---|
1610 | declare 452 generic { |
---|
1611 | int Tcl_FSFileAttrsSet(Tcl_Interp *interp, |
---|
1612 | int index, Tcl_Obj *pathPtr, Tcl_Obj *objPtr) |
---|
1613 | } |
---|
1614 | declare 453 generic { |
---|
1615 | CONST char ** Tcl_FSFileAttrStrings(Tcl_Obj *pathPtr, Tcl_Obj **objPtrRef) |
---|
1616 | } |
---|
1617 | declare 454 generic { |
---|
1618 | int Tcl_FSStat(Tcl_Obj *pathPtr, Tcl_StatBuf *buf) |
---|
1619 | } |
---|
1620 | declare 455 generic { |
---|
1621 | int Tcl_FSAccess(Tcl_Obj *pathPtr, int mode) |
---|
1622 | } |
---|
1623 | declare 456 generic { |
---|
1624 | Tcl_Channel Tcl_FSOpenFileChannel(Tcl_Interp *interp, Tcl_Obj *pathPtr, |
---|
1625 | CONST char *modeString, int permissions) |
---|
1626 | } |
---|
1627 | declare 457 generic { |
---|
1628 | Tcl_Obj* Tcl_FSGetCwd(Tcl_Interp *interp) |
---|
1629 | } |
---|
1630 | declare 458 generic { |
---|
1631 | int Tcl_FSChdir(Tcl_Obj *pathPtr) |
---|
1632 | } |
---|
1633 | declare 459 generic { |
---|
1634 | int Tcl_FSConvertToPathType(Tcl_Interp *interp, Tcl_Obj *pathPtr) |
---|
1635 | } |
---|
1636 | declare 460 generic { |
---|
1637 | Tcl_Obj* Tcl_FSJoinPath(Tcl_Obj *listObj, int elements) |
---|
1638 | } |
---|
1639 | declare 461 generic { |
---|
1640 | Tcl_Obj* Tcl_FSSplitPath(Tcl_Obj* pathPtr, int *lenPtr) |
---|
1641 | } |
---|
1642 | declare 462 generic { |
---|
1643 | int Tcl_FSEqualPaths(Tcl_Obj* firstPtr, Tcl_Obj* secondPtr) |
---|
1644 | } |
---|
1645 | declare 463 generic { |
---|
1646 | Tcl_Obj* Tcl_FSGetNormalizedPath(Tcl_Interp *interp, Tcl_Obj* pathPtr) |
---|
1647 | } |
---|
1648 | declare 464 generic { |
---|
1649 | Tcl_Obj* Tcl_FSJoinToPath(Tcl_Obj *pathPtr, int objc, |
---|
1650 | Tcl_Obj *CONST objv[]) |
---|
1651 | } |
---|
1652 | declare 465 generic { |
---|
1653 | ClientData Tcl_FSGetInternalRep(Tcl_Obj* pathPtr, |
---|
1654 | Tcl_Filesystem *fsPtr) |
---|
1655 | } |
---|
1656 | declare 466 generic { |
---|
1657 | Tcl_Obj* Tcl_FSGetTranslatedPath(Tcl_Interp *interp, Tcl_Obj* pathPtr) |
---|
1658 | } |
---|
1659 | declare 467 generic { |
---|
1660 | int Tcl_FSEvalFile(Tcl_Interp *interp, Tcl_Obj *fileName) |
---|
1661 | } |
---|
1662 | declare 468 generic { |
---|
1663 | Tcl_Obj* Tcl_FSNewNativePath(Tcl_Filesystem* fromFilesystem, |
---|
1664 | ClientData clientData) |
---|
1665 | } |
---|
1666 | declare 469 generic { |
---|
1667 | CONST char* Tcl_FSGetNativePath(Tcl_Obj* pathPtr) |
---|
1668 | } |
---|
1669 | declare 470 generic { |
---|
1670 | Tcl_Obj* Tcl_FSFileSystemInfo(Tcl_Obj* pathPtr) |
---|
1671 | } |
---|
1672 | declare 471 generic { |
---|
1673 | Tcl_Obj* Tcl_FSPathSeparator(Tcl_Obj* pathPtr) |
---|
1674 | } |
---|
1675 | declare 472 generic { |
---|
1676 | Tcl_Obj* Tcl_FSListVolumes(void) |
---|
1677 | } |
---|
1678 | declare 473 generic { |
---|
1679 | int Tcl_FSRegister(ClientData clientData, Tcl_Filesystem *fsPtr) |
---|
1680 | } |
---|
1681 | declare 474 generic { |
---|
1682 | int Tcl_FSUnregister(Tcl_Filesystem *fsPtr) |
---|
1683 | } |
---|
1684 | declare 475 generic { |
---|
1685 | ClientData Tcl_FSData(Tcl_Filesystem *fsPtr) |
---|
1686 | } |
---|
1687 | declare 476 generic { |
---|
1688 | CONST char* Tcl_FSGetTranslatedStringPath(Tcl_Interp *interp, |
---|
1689 | Tcl_Obj* pathPtr) |
---|
1690 | } |
---|
1691 | declare 477 generic { |
---|
1692 | Tcl_Filesystem* Tcl_FSGetFileSystemForPath(Tcl_Obj* pathPtr) |
---|
1693 | } |
---|
1694 | declare 478 generic { |
---|
1695 | Tcl_PathType Tcl_FSGetPathType(Tcl_Obj *pathPtr) |
---|
1696 | } |
---|
1697 | # New function due to TIP#49 |
---|
1698 | declare 479 generic { |
---|
1699 | int Tcl_OutputBuffered(Tcl_Channel chan) |
---|
1700 | } |
---|
1701 | declare 480 generic { |
---|
1702 | void Tcl_FSMountsChanged(Tcl_Filesystem *fsPtr) |
---|
1703 | } |
---|
1704 | # New function due to TIP#56 |
---|
1705 | declare 481 generic { |
---|
1706 | int Tcl_EvalTokensStandard(Tcl_Interp *interp, Tcl_Token *tokenPtr, |
---|
1707 | int count) |
---|
1708 | } |
---|
1709 | |
---|
1710 | # New export due to TIP#73 |
---|
1711 | declare 482 generic { |
---|
1712 | void Tcl_GetTime(Tcl_Time* timeBuf) |
---|
1713 | } |
---|
1714 | |
---|
1715 | # New exports due to TIP#32 |
---|
1716 | |
---|
1717 | declare 483 generic { |
---|
1718 | Tcl_Trace Tcl_CreateObjTrace(Tcl_Interp* interp, int level, int flags, |
---|
1719 | Tcl_CmdObjTraceProc* objProc, ClientData clientData, |
---|
1720 | Tcl_CmdObjTraceDeleteProc* delProc) |
---|
1721 | } |
---|
1722 | declare 484 generic { |
---|
1723 | int Tcl_GetCommandInfoFromToken(Tcl_Command token, Tcl_CmdInfo* infoPtr) |
---|
1724 | } |
---|
1725 | declare 485 generic { |
---|
1726 | int Tcl_SetCommandInfoFromToken(Tcl_Command token, |
---|
1727 | CONST Tcl_CmdInfo* infoPtr) |
---|
1728 | } |
---|
1729 | |
---|
1730 | ### New functions on 64-bit dev branch ### |
---|
1731 | declare 486 generic { |
---|
1732 | Tcl_Obj * Tcl_DbNewWideIntObj(Tcl_WideInt wideValue, |
---|
1733 | CONST char *file, int line) |
---|
1734 | } |
---|
1735 | declare 487 generic { |
---|
1736 | int Tcl_GetWideIntFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, |
---|
1737 | Tcl_WideInt *widePtr) |
---|
1738 | } |
---|
1739 | declare 488 generic { |
---|
1740 | Tcl_Obj * Tcl_NewWideIntObj(Tcl_WideInt wideValue) |
---|
1741 | } |
---|
1742 | declare 489 generic { |
---|
1743 | void Tcl_SetWideIntObj(Tcl_Obj *objPtr, Tcl_WideInt wideValue) |
---|
1744 | } |
---|
1745 | declare 490 generic { |
---|
1746 | Tcl_StatBuf * Tcl_AllocStatBuf(void) |
---|
1747 | } |
---|
1748 | declare 491 generic { |
---|
1749 | Tcl_WideInt Tcl_Seek(Tcl_Channel chan, Tcl_WideInt offset, int mode) |
---|
1750 | } |
---|
1751 | declare 492 generic { |
---|
1752 | Tcl_WideInt Tcl_Tell(Tcl_Channel chan) |
---|
1753 | } |
---|
1754 | |
---|
1755 | # New export due to TIP#91 |
---|
1756 | declare 493 generic { |
---|
1757 | Tcl_DriverWideSeekProc * Tcl_ChannelWideSeekProc( |
---|
1758 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1759 | } |
---|
1760 | |
---|
1761 | # DICTIONARIES - TIP#111 |
---|
1762 | declare 494 generic { |
---|
1763 | int Tcl_DictObjPut(Tcl_Interp *interp, Tcl_Obj *dictPtr, |
---|
1764 | Tcl_Obj *keyPtr, Tcl_Obj *valuePtr) |
---|
1765 | } |
---|
1766 | declare 495 generic { |
---|
1767 | int Tcl_DictObjGet(Tcl_Interp *interp, Tcl_Obj *dictPtr, Tcl_Obj *keyPtr, |
---|
1768 | Tcl_Obj **valuePtrPtr) |
---|
1769 | } |
---|
1770 | declare 496 generic { |
---|
1771 | int Tcl_DictObjRemove(Tcl_Interp *interp, Tcl_Obj *dictPtr, |
---|
1772 | Tcl_Obj *keyPtr) |
---|
1773 | } |
---|
1774 | declare 497 generic { |
---|
1775 | int Tcl_DictObjSize(Tcl_Interp *interp, Tcl_Obj *dictPtr, int *sizePtr) |
---|
1776 | } |
---|
1777 | declare 498 generic { |
---|
1778 | int Tcl_DictObjFirst(Tcl_Interp *interp, Tcl_Obj *dictPtr, |
---|
1779 | Tcl_DictSearch *searchPtr, |
---|
1780 | Tcl_Obj **keyPtrPtr, Tcl_Obj **valuePtrPtr, int *donePtr) |
---|
1781 | } |
---|
1782 | declare 499 generic { |
---|
1783 | void Tcl_DictObjNext(Tcl_DictSearch *searchPtr, |
---|
1784 | Tcl_Obj **keyPtrPtr, Tcl_Obj **valuePtrPtr, int *donePtr) |
---|
1785 | } |
---|
1786 | declare 500 generic { |
---|
1787 | void Tcl_DictObjDone(Tcl_DictSearch *searchPtr) |
---|
1788 | } |
---|
1789 | declare 501 generic { |
---|
1790 | int Tcl_DictObjPutKeyList(Tcl_Interp *interp, Tcl_Obj *dictPtr, |
---|
1791 | int keyc, Tcl_Obj *CONST *keyv, Tcl_Obj *valuePtr) |
---|
1792 | } |
---|
1793 | declare 502 generic { |
---|
1794 | int Tcl_DictObjRemoveKeyList(Tcl_Interp *interp, Tcl_Obj *dictPtr, |
---|
1795 | int keyc, Tcl_Obj *CONST *keyv) |
---|
1796 | } |
---|
1797 | declare 503 generic { |
---|
1798 | Tcl_Obj *Tcl_NewDictObj(void) |
---|
1799 | } |
---|
1800 | declare 504 generic { |
---|
1801 | Tcl_Obj *Tcl_DbNewDictObj(CONST char *file, int line) |
---|
1802 | } |
---|
1803 | |
---|
1804 | # New export due to TIP#59 |
---|
1805 | declare 505 generic { |
---|
1806 | void Tcl_RegisterConfig(Tcl_Interp* interp, CONST char* pkgName, |
---|
1807 | Tcl_Config* configuration, CONST char* valEncoding) |
---|
1808 | } |
---|
1809 | |
---|
1810 | # Transferred from tclInt.decls due to TIP #139 |
---|
1811 | declare 506 generic { |
---|
1812 | Tcl_Namespace *Tcl_CreateNamespace(Tcl_Interp *interp, CONST char *name, |
---|
1813 | ClientData clientData, Tcl_NamespaceDeleteProc *deleteProc) |
---|
1814 | } |
---|
1815 | declare 507 generic { |
---|
1816 | void Tcl_DeleteNamespace(Tcl_Namespace *nsPtr) |
---|
1817 | } |
---|
1818 | declare 508 generic { |
---|
1819 | int Tcl_AppendExportList(Tcl_Interp *interp, Tcl_Namespace *nsPtr, |
---|
1820 | Tcl_Obj *objPtr) |
---|
1821 | } |
---|
1822 | declare 509 generic { |
---|
1823 | int Tcl_Export(Tcl_Interp *interp, Tcl_Namespace *nsPtr, |
---|
1824 | CONST char *pattern, int resetListFirst) |
---|
1825 | } |
---|
1826 | declare 510 generic { |
---|
1827 | int Tcl_Import(Tcl_Interp *interp, Tcl_Namespace *nsPtr, |
---|
1828 | CONST char *pattern, int allowOverwrite) |
---|
1829 | } |
---|
1830 | declare 511 generic { |
---|
1831 | int Tcl_ForgetImport(Tcl_Interp *interp, Tcl_Namespace *nsPtr, |
---|
1832 | CONST char *pattern) |
---|
1833 | } |
---|
1834 | declare 512 generic { |
---|
1835 | Tcl_Namespace *Tcl_GetCurrentNamespace(Tcl_Interp *interp) |
---|
1836 | } |
---|
1837 | declare 513 generic { |
---|
1838 | Tcl_Namespace *Tcl_GetGlobalNamespace(Tcl_Interp *interp) |
---|
1839 | } |
---|
1840 | declare 514 generic { |
---|
1841 | Tcl_Namespace *Tcl_FindNamespace(Tcl_Interp *interp, CONST char *name, |
---|
1842 | Tcl_Namespace *contextNsPtr, int flags) |
---|
1843 | } |
---|
1844 | declare 515 generic { |
---|
1845 | Tcl_Command Tcl_FindCommand(Tcl_Interp *interp, CONST char *name, |
---|
1846 | Tcl_Namespace *contextNsPtr, int flags) |
---|
1847 | } |
---|
1848 | declare 516 generic { |
---|
1849 | Tcl_Command Tcl_GetCommandFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr) |
---|
1850 | } |
---|
1851 | declare 517 generic { |
---|
1852 | void Tcl_GetCommandFullName(Tcl_Interp *interp, Tcl_Command command, |
---|
1853 | Tcl_Obj *objPtr) |
---|
1854 | } |
---|
1855 | |
---|
1856 | # New export due to TIP#137 |
---|
1857 | declare 518 generic { |
---|
1858 | int Tcl_FSEvalFileEx(Tcl_Interp *interp, Tcl_Obj *fileName, |
---|
1859 | CONST char *encodingName) |
---|
1860 | } |
---|
1861 | |
---|
1862 | # New export due to TIP#121 |
---|
1863 | declare 519 generic { |
---|
1864 | Tcl_ExitProc *Tcl_SetExitProc(Tcl_ExitProc *proc) |
---|
1865 | } |
---|
1866 | |
---|
1867 | # TIP#143 API |
---|
1868 | declare 520 generic { |
---|
1869 | void Tcl_LimitAddHandler(Tcl_Interp *interp, int type, |
---|
1870 | Tcl_LimitHandlerProc *handlerProc, ClientData clientData, |
---|
1871 | Tcl_LimitHandlerDeleteProc *deleteProc) |
---|
1872 | } |
---|
1873 | declare 521 generic { |
---|
1874 | void Tcl_LimitRemoveHandler(Tcl_Interp *interp, int type, |
---|
1875 | Tcl_LimitHandlerProc *handlerProc, ClientData clientData) |
---|
1876 | } |
---|
1877 | declare 522 generic { |
---|
1878 | int Tcl_LimitReady(Tcl_Interp *interp) |
---|
1879 | } |
---|
1880 | declare 523 generic { |
---|
1881 | int Tcl_LimitCheck(Tcl_Interp *interp) |
---|
1882 | } |
---|
1883 | declare 524 generic { |
---|
1884 | int Tcl_LimitExceeded(Tcl_Interp *interp) |
---|
1885 | } |
---|
1886 | declare 525 generic { |
---|
1887 | void Tcl_LimitSetCommands(Tcl_Interp *interp, int commandLimit) |
---|
1888 | } |
---|
1889 | declare 526 generic { |
---|
1890 | void Tcl_LimitSetTime(Tcl_Interp *interp, Tcl_Time *timeLimitPtr) |
---|
1891 | } |
---|
1892 | declare 527 generic { |
---|
1893 | void Tcl_LimitSetGranularity(Tcl_Interp *interp, int type, int granularity) |
---|
1894 | } |
---|
1895 | declare 528 generic { |
---|
1896 | int Tcl_LimitTypeEnabled(Tcl_Interp *interp, int type) |
---|
1897 | } |
---|
1898 | declare 529 generic { |
---|
1899 | int Tcl_LimitTypeExceeded(Tcl_Interp *interp, int type) |
---|
1900 | } |
---|
1901 | declare 530 generic { |
---|
1902 | void Tcl_LimitTypeSet(Tcl_Interp *interp, int type) |
---|
1903 | } |
---|
1904 | declare 531 generic { |
---|
1905 | void Tcl_LimitTypeReset(Tcl_Interp *interp, int type) |
---|
1906 | } |
---|
1907 | declare 532 generic { |
---|
1908 | int Tcl_LimitGetCommands(Tcl_Interp *interp) |
---|
1909 | } |
---|
1910 | declare 533 generic { |
---|
1911 | void Tcl_LimitGetTime(Tcl_Interp *interp, Tcl_Time *timeLimitPtr) |
---|
1912 | } |
---|
1913 | declare 534 generic { |
---|
1914 | int Tcl_LimitGetGranularity(Tcl_Interp *interp, int type) |
---|
1915 | } |
---|
1916 | # TIP#226 API |
---|
1917 | declare 535 generic { |
---|
1918 | Tcl_InterpState Tcl_SaveInterpState(Tcl_Interp *interp, int status) |
---|
1919 | } |
---|
1920 | declare 536 generic { |
---|
1921 | int Tcl_RestoreInterpState(Tcl_Interp *interp, Tcl_InterpState state) |
---|
1922 | } |
---|
1923 | declare 537 generic { |
---|
1924 | void Tcl_DiscardInterpState(Tcl_InterpState state) |
---|
1925 | } |
---|
1926 | # TIP#227 API |
---|
1927 | declare 538 generic { |
---|
1928 | int Tcl_SetReturnOptions(Tcl_Interp *interp, Tcl_Obj *options) |
---|
1929 | } |
---|
1930 | declare 539 generic { |
---|
1931 | Tcl_Obj *Tcl_GetReturnOptions(Tcl_Interp *interp, int result) |
---|
1932 | } |
---|
1933 | # TIP#235 |
---|
1934 | declare 540 generic { |
---|
1935 | int Tcl_IsEnsemble(Tcl_Command token) |
---|
1936 | } |
---|
1937 | declare 541 generic { |
---|
1938 | Tcl_Command Tcl_CreateEnsemble(Tcl_Interp *interp, CONST char *name, |
---|
1939 | Tcl_Namespace *namespacePtr, int flags) |
---|
1940 | } |
---|
1941 | declare 542 generic { |
---|
1942 | Tcl_Command Tcl_FindEnsemble(Tcl_Interp *interp, Tcl_Obj *cmdNameObj, |
---|
1943 | int flags) |
---|
1944 | } |
---|
1945 | declare 543 generic { |
---|
1946 | int Tcl_SetEnsembleSubcommandList(Tcl_Interp *interp, Tcl_Command token, |
---|
1947 | Tcl_Obj *subcmdList) |
---|
1948 | } |
---|
1949 | declare 544 generic { |
---|
1950 | int Tcl_SetEnsembleMappingDict(Tcl_Interp *interp, Tcl_Command token, |
---|
1951 | Tcl_Obj *mapDict) |
---|
1952 | } |
---|
1953 | declare 545 generic { |
---|
1954 | int Tcl_SetEnsembleUnknownHandler(Tcl_Interp *interp, Tcl_Command token, |
---|
1955 | Tcl_Obj *unknownList) |
---|
1956 | } |
---|
1957 | declare 546 generic { |
---|
1958 | int Tcl_SetEnsembleFlags(Tcl_Interp *interp, Tcl_Command token, int flags) |
---|
1959 | } |
---|
1960 | declare 547 generic { |
---|
1961 | int Tcl_GetEnsembleSubcommandList(Tcl_Interp *interp, Tcl_Command token, |
---|
1962 | Tcl_Obj **subcmdListPtr) |
---|
1963 | } |
---|
1964 | declare 548 generic { |
---|
1965 | int Tcl_GetEnsembleMappingDict(Tcl_Interp *interp, Tcl_Command token, |
---|
1966 | Tcl_Obj **mapDictPtr) |
---|
1967 | } |
---|
1968 | declare 549 generic { |
---|
1969 | int Tcl_GetEnsembleUnknownHandler(Tcl_Interp *interp, Tcl_Command token, |
---|
1970 | Tcl_Obj **unknownListPtr) |
---|
1971 | } |
---|
1972 | declare 550 generic { |
---|
1973 | int Tcl_GetEnsembleFlags(Tcl_Interp *interp, Tcl_Command token, |
---|
1974 | int *flagsPtr) |
---|
1975 | } |
---|
1976 | declare 551 generic { |
---|
1977 | int Tcl_GetEnsembleNamespace(Tcl_Interp *interp, Tcl_Command token, |
---|
1978 | Tcl_Namespace **namespacePtrPtr) |
---|
1979 | } |
---|
1980 | # TIP#233 (Virtualized Time) |
---|
1981 | declare 552 generic { |
---|
1982 | void Tcl_SetTimeProc(Tcl_GetTimeProc* getProc, |
---|
1983 | Tcl_ScaleTimeProc* scaleProc, |
---|
1984 | ClientData clientData) |
---|
1985 | } |
---|
1986 | declare 553 generic { |
---|
1987 | void Tcl_QueryTimeProc(Tcl_GetTimeProc** getProc, |
---|
1988 | Tcl_ScaleTimeProc** scaleProc, |
---|
1989 | ClientData* clientData) |
---|
1990 | } |
---|
1991 | # TIP#218 (Driver Thread Actions) davygrvy/akupries ChannelType ver 4 |
---|
1992 | declare 554 generic { |
---|
1993 | Tcl_DriverThreadActionProc *Tcl_ChannelThreadActionProc( |
---|
1994 | CONST Tcl_ChannelType *chanTypePtr) |
---|
1995 | } |
---|
1996 | |
---|
1997 | # TIP#237 (Arbitrary-precision Integers) kevin kenny |
---|
1998 | |
---|
1999 | declare 555 generic { |
---|
2000 | Tcl_Obj* Tcl_NewBignumObj(mp_int* value) |
---|
2001 | } |
---|
2002 | declare 556 generic { |
---|
2003 | Tcl_Obj* Tcl_DbNewBignumObj(mp_int* value, CONST char* file, int line) |
---|
2004 | } |
---|
2005 | declare 557 generic { |
---|
2006 | void Tcl_SetBignumObj(Tcl_Obj* obj, mp_int* value) |
---|
2007 | } |
---|
2008 | declare 558 generic { |
---|
2009 | int Tcl_GetBignumFromObj(Tcl_Interp* interp, Tcl_Obj* obj, mp_int* value) |
---|
2010 | } |
---|
2011 | declare 559 generic { |
---|
2012 | int Tcl_TakeBignumFromObj(Tcl_Interp* interp, Tcl_Obj* obj, mp_int* value) |
---|
2013 | } |
---|
2014 | |
---|
2015 | # TIP #208 ('chan' Command) jeffh |
---|
2016 | declare 560 generic { |
---|
2017 | int Tcl_TruncateChannel(Tcl_Channel chan, Tcl_WideInt length) |
---|
2018 | } |
---|
2019 | declare 561 generic { |
---|
2020 | Tcl_DriverTruncateProc *Tcl_ChannelTruncateProc( |
---|
2021 | CONST Tcl_ChannelType *chanTypePtr) |
---|
2022 | } |
---|
2023 | |
---|
2024 | # TIP#219 (Tcl Channel Reflection API) akupries |
---|
2025 | |
---|
2026 | declare 562 generic { |
---|
2027 | void Tcl_SetChannelErrorInterp(Tcl_Interp* interp, Tcl_Obj* msg) |
---|
2028 | } |
---|
2029 | declare 563 generic { |
---|
2030 | void Tcl_GetChannelErrorInterp(Tcl_Interp* interp, Tcl_Obj** msg) |
---|
2031 | } |
---|
2032 | declare 564 generic { |
---|
2033 | void Tcl_SetChannelError(Tcl_Channel chan, Tcl_Obj* msg) |
---|
2034 | } |
---|
2035 | declare 565 generic { |
---|
2036 | void Tcl_GetChannelError(Tcl_Channel chan, Tcl_Obj** msg) |
---|
2037 | } |
---|
2038 | |
---|
2039 | # TIP #237 (Additional conversion functions for bignum support) |
---|
2040 | |
---|
2041 | declare 566 generic { |
---|
2042 | int Tcl_InitBignumFromDouble(Tcl_Interp* interp, double initval, |
---|
2043 | mp_int *toInit) |
---|
2044 | } |
---|
2045 | |
---|
2046 | # TIP#181 (namespace unknown Command) |
---|
2047 | declare 567 generic { |
---|
2048 | Tcl_Obj *Tcl_GetNamespaceUnknownHandler(Tcl_Interp *interp, |
---|
2049 | Tcl_Namespace *nsPtr) |
---|
2050 | } |
---|
2051 | declare 568 generic { |
---|
2052 | int Tcl_SetNamespaceUnknownHandler( |
---|
2053 | Tcl_Interp *interp, Tcl_Namespace *nsPtr, |
---|
2054 | Tcl_Obj *handlerPtr) |
---|
2055 | } |
---|
2056 | |
---|
2057 | # TIP#258 (Enhanced Interface for Encodings) |
---|
2058 | |
---|
2059 | declare 569 generic { |
---|
2060 | int Tcl_GetEncodingFromObj(Tcl_Interp* interp, Tcl_Obj* objPtr, |
---|
2061 | Tcl_Encoding* encodingPtr) |
---|
2062 | } |
---|
2063 | declare 570 generic { |
---|
2064 | Tcl_Obj* Tcl_GetEncodingSearchPath(void) |
---|
2065 | } |
---|
2066 | declare 571 generic { |
---|
2067 | int Tcl_SetEncodingSearchPath(Tcl_Obj* searchPath) |
---|
2068 | } |
---|
2069 | declare 572 generic { |
---|
2070 | CONST char *Tcl_GetEncodingNameFromEnvironment(Tcl_DString* bufPtr) |
---|
2071 | } |
---|
2072 | |
---|
2073 | # TIP#268: Extended version numbers and requirements |
---|
2074 | declare 573 generic { |
---|
2075 | int Tcl_PkgRequireProc(Tcl_Interp *interp, CONST char *name, |
---|
2076 | int objc, Tcl_Obj *CONST objv[], ClientData *clientDataPtr) |
---|
2077 | } |
---|
2078 | |
---|
2079 | # TIP#270 Utility C Routines for String Formatting |
---|
2080 | declare 574 generic { |
---|
2081 | void Tcl_AppendObjToErrorInfo(Tcl_Interp *interp, Tcl_Obj *objPtr) |
---|
2082 | } |
---|
2083 | declare 575 generic { |
---|
2084 | void Tcl_AppendLimitedToObj(Tcl_Obj *objPtr, CONST char *bytes, int length, |
---|
2085 | int limit, CONST char *ellipsis) |
---|
2086 | } |
---|
2087 | declare 576 generic { |
---|
2088 | Tcl_Obj * Tcl_Format(Tcl_Interp *interp, CONST char *format, int objc, |
---|
2089 | Tcl_Obj * CONST objv[]) |
---|
2090 | } |
---|
2091 | declare 577 generic { |
---|
2092 | int Tcl_AppendFormatToObj(Tcl_Interp *interp, Tcl_Obj *objPtr, |
---|
2093 | CONST char *format, int objc, Tcl_Obj * CONST objv[]) |
---|
2094 | } |
---|
2095 | declare 578 generic { |
---|
2096 | Tcl_Obj * Tcl_ObjPrintf(CONST char *format, ...) |
---|
2097 | } |
---|
2098 | declare 579 generic { |
---|
2099 | void Tcl_AppendPrintfToObj(Tcl_Obj *objPtr, CONST char *format, ...) |
---|
2100 | } |
---|
2101 | |
---|
2102 | ############################################################################## |
---|
2103 | |
---|
2104 | # Define the platform specific public Tcl interface. These functions are |
---|
2105 | # only available on the designated platform. |
---|
2106 | |
---|
2107 | interface tclPlat |
---|
2108 | |
---|
2109 | ################################ |
---|
2110 | # Unix specific functions |
---|
2111 | # (none) |
---|
2112 | |
---|
2113 | ################################ |
---|
2114 | # Windows specific functions |
---|
2115 | |
---|
2116 | # Added in Tcl 8.1 |
---|
2117 | |
---|
2118 | declare 0 win { |
---|
2119 | TCHAR * Tcl_WinUtfToTChar(CONST char *str, int len, Tcl_DString *dsPtr) |
---|
2120 | } |
---|
2121 | declare 1 win { |
---|
2122 | char * Tcl_WinTCharToUtf(CONST TCHAR *str, int len, Tcl_DString *dsPtr) |
---|
2123 | } |
---|
2124 | |
---|
2125 | ################################ |
---|
2126 | # Mac OS X specific functions |
---|
2127 | |
---|
2128 | declare 0 macosx { |
---|
2129 | int Tcl_MacOSXOpenBundleResources(Tcl_Interp *interp, |
---|
2130 | CONST char *bundleName, |
---|
2131 | int hasResourceFile, |
---|
2132 | int maxPathLen, |
---|
2133 | char *libraryPath) |
---|
2134 | } |
---|
2135 | declare 1 macosx { |
---|
2136 | int Tcl_MacOSXOpenVersionedBundleResources(Tcl_Interp *interp, |
---|
2137 | CONST char *bundleName, |
---|
2138 | CONST char *bundleVersion, |
---|
2139 | int hasResourceFile, |
---|
2140 | int maxPathLen, |
---|
2141 | char *libraryPath) |
---|
2142 | } |
---|
2143 | |
---|
2144 | ############################################################################## |
---|
2145 | |
---|
2146 | # Public functions that are not accessible via the stubs table. |
---|
2147 | |
---|
2148 | export { |
---|
2149 | void Tcl_Main(int argc, char **argv, Tcl_AppInitProc *appInitProc) |
---|
2150 | } |
---|
2151 | export { |
---|
2152 | CONST char *Tcl_InitStubs(Tcl_Interp *interp, CONST char *version, |
---|
2153 | int exact) |
---|
2154 | } |
---|
2155 | export { |
---|
2156 | CONST char *TclTomMathInitializeStubs(Tcl_Interp* interp, |
---|
2157 | CONST char* version, int epoch, int revision) |
---|
2158 | } |
---|
2159 | export { |
---|
2160 | CONST char *Tcl_PkgInitStubsCheck(Tcl_Interp *interp, CONST char *version, |
---|
2161 | int exact) |
---|
2162 | } |
---|
2163 | export { |
---|
2164 | void Tcl_GetMemoryInfo(Tcl_DString *dsPtr) |
---|
2165 | } |
---|
2166 | |
---|
2167 | # Global variables that need to be exported from the tcl shared library. |
---|
2168 | |
---|
2169 | export { |
---|
2170 | TclStubs *tclStubsPtr (fool checkstubs) |
---|
2171 | } |
---|
2172 | export { |
---|
2173 | TclPlatStubs *tclPlatStubsPtr (fool checkstubs) |
---|
2174 | } |
---|
2175 | export { |
---|
2176 | TclIntStubs *tclIntStubsPtr (fool checkstubs) |
---|
2177 | } |
---|
2178 | export { |
---|
2179 | TclIntPlatStubs *tclIntPlatStubsPtr (fool checkstubs) |
---|
2180 | } |
---|
2181 | export { |
---|
2182 | TclTomMathStubs* tclTomMathStubsPtr (fool checkstubs) |
---|
2183 | } |
---|