#include "tcl.h"
#undef Tcl_Alloc
#undef Tcl_Free
#undef Tcl_Realloc
#undef Tcl_NewBooleanObj
#undef Tcl_NewByteArrayObj
#undef Tcl_NewDoubleObj
#undef Tcl_NewIntObj
#undef Tcl_NewListObj
#undef Tcl_NewLongObj
#undef Tcl_NewObj
#undef Tcl_NewStringObj
#undef Tcl_InitMemory
#undef Tcl_DumpActiveMemory
#undef Tcl_ValidateAllMemory
#undef Tcl_EvalObj
#undef Tcl_GlobalEvalObj
#undef Tcl_MutexLock
#undef Tcl_MutexUnlock
#undef Tcl_ConditionNotify
#undef Tcl_ConditionWait
int
Tcl_PkgProvideEx(interp, name, version, clientData)
Tcl_Interp * interp;
char * name;
char * version;
ClientData clientData;
{
return (tclStubsPtr->tcl_PkgProvideEx)(interp, name, version, clientData);
}
char *
Tcl_PkgRequireEx(interp, name, version, exact, clientDataPtr)
Tcl_Interp * interp;
char * name;
char * version;
int exact;
ClientData * clientDataPtr;
{
return (tclStubsPtr->tcl_PkgRequireEx)(interp, name, version, exact, clientDataPtr);
}
void
Tcl_Panic TCL_VARARGS_DEF(char *,format)
{
char * var;
va_list argList;
var = (char *) TCL_VARARGS_START(char *,format,argList);
(tclStubsPtr->tcl_PanicVA)(var, argList);
va_end(argList);
}
char *
Tcl_Alloc(size)
unsigned int size;
{
return (tclStubsPtr->tcl_Alloc)(size);
}
void
Tcl_Free(ptr)
char * ptr;
{
(tclStubsPtr->tcl_Free)(ptr);
}
char *
Tcl_Realloc(ptr, size)
char * ptr;
unsigned int size;
{
return (tclStubsPtr->tcl_Realloc)(ptr, size);
}
char *
Tcl_DbCkalloc(size, file, line)
unsigned int size;
char * file;
int line;
{
return (tclStubsPtr->tcl_DbCkalloc)(size, file, line);
}
int
Tcl_DbCkfree(ptr, file, line)
char * ptr;
char * file;
int line;
{
return (tclStubsPtr->tcl_DbCkfree)(ptr, file, line);
}
char *
Tcl_DbCkrealloc(ptr, size, file, line)
char * ptr;
unsigned int size;
char * file;
int line;
{
return (tclStubsPtr->tcl_DbCkrealloc)(ptr, size, file, line);
}
#if !defined(__WIN32__) && !defined(MAC_TCL)
void
Tcl_CreateFileHandler(fd, mask, proc, clientData)
int fd;
int mask;
Tcl_FileProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_CreateFileHandler)(fd, mask, proc, clientData);
}
#endif
#if !defined(__WIN32__) && !defined(MAC_TCL)
void
Tcl_DeleteFileHandler(fd)
int fd;
{
(tclStubsPtr->tcl_DeleteFileHandler)(fd);
}
#endif
void
Tcl_SetTimer(timePtr)
Tcl_Time * timePtr;
{
(tclStubsPtr->tcl_SetTimer)(timePtr);
}
void
Tcl_Sleep(ms)
int ms;
{
(tclStubsPtr->tcl_Sleep)(ms);
}
int
Tcl_WaitForEvent(timePtr)
Tcl_Time * timePtr;
{
return (tclStubsPtr->tcl_WaitForEvent)(timePtr);
}
int
Tcl_AppendAllObjTypes(interp, objPtr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
{
return (tclStubsPtr->tcl_AppendAllObjTypes)(interp, objPtr);
}
void
Tcl_AppendStringsToObj TCL_VARARGS_DEF(Tcl_Obj *,objPtr)
{
Tcl_Obj * var;
va_list argList;
var = (Tcl_Obj *) TCL_VARARGS_START(Tcl_Obj *,objPtr,argList);
(tclStubsPtr->tcl_AppendStringsToObjVA)(var, argList);
va_end(argList);
}
void
Tcl_AppendToObj(objPtr, bytes, length)
Tcl_Obj * objPtr;
char * bytes;
int length;
{
(tclStubsPtr->tcl_AppendToObj)(objPtr, bytes, length);
}
Tcl_Obj *
Tcl_ConcatObj(objc, objv)
int objc;
Tcl_Obj *CONST objv[];
{
return (tclStubsPtr->tcl_ConcatObj)(objc, objv);
}
int
Tcl_ConvertToType(interp, objPtr, typePtr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
Tcl_ObjType * typePtr;
{
return (tclStubsPtr->tcl_ConvertToType)(interp, objPtr, typePtr);
}
void
Tcl_DbDecrRefCount(objPtr, file, line)
Tcl_Obj * objPtr;
char * file;
int line;
{
(tclStubsPtr->tcl_DbDecrRefCount)(objPtr, file, line);
}
void
Tcl_DbIncrRefCount(objPtr, file, line)
Tcl_Obj * objPtr;
char * file;
int line;
{
(tclStubsPtr->tcl_DbIncrRefCount)(objPtr, file, line);
}
int
Tcl_DbIsShared(objPtr, file, line)
Tcl_Obj * objPtr;
char * file;
int line;
{
return (tclStubsPtr->tcl_DbIsShared)(objPtr, file, line);
}
Tcl_Obj *
Tcl_DbNewBooleanObj(boolValue, file, line)
int boolValue;
char * file;
int line;
{
return (tclStubsPtr->tcl_DbNewBooleanObj)(boolValue, file, line);
}
Tcl_Obj *
Tcl_DbNewByteArrayObj(bytes, length, file, line)
unsigned char * bytes;
int length;
char * file;
int line;
{
return (tclStubsPtr->tcl_DbNewByteArrayObj)(bytes, length, file, line);
}
Tcl_Obj *
Tcl_DbNewDoubleObj(doubleValue, file, line)
double doubleValue;
char * file;
int line;
{
return (tclStubsPtr->tcl_DbNewDoubleObj)(doubleValue, file, line);
}
Tcl_Obj *
Tcl_DbNewListObj(objc, objv, file, line)
int objc;
Tcl_Obj *CONST objv[];
char * file;
int line;
{
return (tclStubsPtr->tcl_DbNewListObj)(objc, objv, file, line);
}
Tcl_Obj *
Tcl_DbNewLongObj(longValue, file, line)
long longValue;
char * file;
int line;
{
return (tclStubsPtr->tcl_DbNewLongObj)(longValue, file, line);
}
Tcl_Obj *
Tcl_DbNewObj(file, line)
char * file;
int line;
{
return (tclStubsPtr->tcl_DbNewObj)(file, line);
}
Tcl_Obj *
Tcl_DbNewStringObj(bytes, length, file, line)
CONST char * bytes;
int length;
char * file;
int line;
{
return (tclStubsPtr->tcl_DbNewStringObj)(bytes, length, file, line);
}
Tcl_Obj *
Tcl_DuplicateObj(objPtr)
Tcl_Obj * objPtr;
{
return (tclStubsPtr->tcl_DuplicateObj)(objPtr);
}
void
TclFreeObj(objPtr)
Tcl_Obj * objPtr;
{
(tclStubsPtr->tclFreeObj)(objPtr);
}
int
Tcl_GetBoolean(interp, str, boolPtr)
Tcl_Interp * interp;
char * str;
int * boolPtr;
{
return (tclStubsPtr->tcl_GetBoolean)(interp, str, boolPtr);
}
int
Tcl_GetBooleanFromObj(interp, objPtr, boolPtr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
int * boolPtr;
{
return (tclStubsPtr->tcl_GetBooleanFromObj)(interp, objPtr, boolPtr);
}
unsigned char *
Tcl_GetByteArrayFromObj(objPtr, lengthPtr)
Tcl_Obj * objPtr;
int * lengthPtr;
{
return (tclStubsPtr->tcl_GetByteArrayFromObj)(objPtr, lengthPtr);
}
int
Tcl_GetDouble(interp, str, doublePtr)
Tcl_Interp * interp;
char * str;
double * doublePtr;
{
return (tclStubsPtr->tcl_GetDouble)(interp, str, doublePtr);
}
int
Tcl_GetDoubleFromObj(interp, objPtr, doublePtr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
double * doublePtr;
{
return (tclStubsPtr->tcl_GetDoubleFromObj)(interp, objPtr, doublePtr);
}
int
Tcl_GetIndexFromObj(interp, objPtr, tablePtr, msg, flags, indexPtr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
char ** tablePtr;
char * msg;
int flags;
int * indexPtr;
{
return (tclStubsPtr->tcl_GetIndexFromObj)(interp, objPtr, tablePtr, msg, flags, indexPtr);
}
int
Tcl_GetInt(interp, str, intPtr)
Tcl_Interp * interp;
char * str;
int * intPtr;
{
return (tclStubsPtr->tcl_GetInt)(interp, str, intPtr);
}
int
Tcl_GetIntFromObj(interp, objPtr, intPtr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
int * intPtr;
{
return (tclStubsPtr->tcl_GetIntFromObj)(interp, objPtr, intPtr);
}
int
Tcl_GetLongFromObj(interp, objPtr, longPtr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
long * longPtr;
{
return (tclStubsPtr->tcl_GetLongFromObj)(interp, objPtr, longPtr);
}
Tcl_ObjType *
Tcl_GetObjType(typeName)
char * typeName;
{
return (tclStubsPtr->tcl_GetObjType)(typeName);
}
char *
Tcl_GetStringFromObj(objPtr, lengthPtr)
Tcl_Obj * objPtr;
int * lengthPtr;
{
return (tclStubsPtr->tcl_GetStringFromObj)(objPtr, lengthPtr);
}
void
Tcl_InvalidateStringRep(objPtr)
Tcl_Obj * objPtr;
{
(tclStubsPtr->tcl_InvalidateStringRep)(objPtr);
}
int
Tcl_ListObjAppendList(interp, listPtr, elemListPtr)
Tcl_Interp * interp;
Tcl_Obj * listPtr;
Tcl_Obj * elemListPtr;
{
return (tclStubsPtr->tcl_ListObjAppendList)(interp, listPtr, elemListPtr);
}
int
Tcl_ListObjAppendElement(interp, listPtr, objPtr)
Tcl_Interp * interp;
Tcl_Obj * listPtr;
Tcl_Obj * objPtr;
{
return (tclStubsPtr->tcl_ListObjAppendElement)(interp, listPtr, objPtr);
}
int
Tcl_ListObjGetElements(interp, listPtr, objcPtr, objvPtr)
Tcl_Interp * interp;
Tcl_Obj * listPtr;
int * objcPtr;
Tcl_Obj *** objvPtr;
{
return (tclStubsPtr->tcl_ListObjGetElements)(interp, listPtr, objcPtr, objvPtr);
}
int
Tcl_ListObjIndex(interp, listPtr, index, objPtrPtr)
Tcl_Interp * interp;
Tcl_Obj * listPtr;
int index;
Tcl_Obj ** objPtrPtr;
{
return (tclStubsPtr->tcl_ListObjIndex)(interp, listPtr, index, objPtrPtr);
}
int
Tcl_ListObjLength(interp, listPtr, intPtr)
Tcl_Interp * interp;
Tcl_Obj * listPtr;
int * intPtr;
{
return (tclStubsPtr->tcl_ListObjLength)(interp, listPtr, intPtr);
}
int
Tcl_ListObjReplace(interp, listPtr, first, count, objc, objv)
Tcl_Interp * interp;
Tcl_Obj * listPtr;
int first;
int count;
int objc;
Tcl_Obj *CONST objv[];
{
return (tclStubsPtr->tcl_ListObjReplace)(interp, listPtr, first, count, objc, objv);
}
Tcl_Obj *
Tcl_NewBooleanObj(boolValue)
int boolValue;
{
return (tclStubsPtr->tcl_NewBooleanObj)(boolValue);
}
Tcl_Obj *
Tcl_NewByteArrayObj(bytes, length)
unsigned char * bytes;
int length;
{
return (tclStubsPtr->tcl_NewByteArrayObj)(bytes, length);
}
Tcl_Obj *
Tcl_NewDoubleObj(doubleValue)
double doubleValue;
{
return (tclStubsPtr->tcl_NewDoubleObj)(doubleValue);
}
Tcl_Obj *
Tcl_NewIntObj(intValue)
int intValue;
{
return (tclStubsPtr->tcl_NewIntObj)(intValue);
}
Tcl_Obj *
Tcl_NewListObj(objc, objv)
int objc;
Tcl_Obj *CONST objv[];
{
return (tclStubsPtr->tcl_NewListObj)(objc, objv);
}
Tcl_Obj *
Tcl_NewLongObj(longValue)
long longValue;
{
return (tclStubsPtr->tcl_NewLongObj)(longValue);
}
Tcl_Obj *
Tcl_NewObj()
{
return (tclStubsPtr->tcl_NewObj)();
}
Tcl_Obj *
Tcl_NewStringObj(bytes, length)
CONST char * bytes;
int length;
{
return (tclStubsPtr->tcl_NewStringObj)(bytes, length);
}
void
Tcl_SetBooleanObj(objPtr, boolValue)
Tcl_Obj * objPtr;
int boolValue;
{
(tclStubsPtr->tcl_SetBooleanObj)(objPtr, boolValue);
}
unsigned char *
Tcl_SetByteArrayLength(objPtr, length)
Tcl_Obj * objPtr;
int length;
{
return (tclStubsPtr->tcl_SetByteArrayLength)(objPtr, length);
}
void
Tcl_SetByteArrayObj(objPtr, bytes, length)
Tcl_Obj * objPtr;
unsigned char * bytes;
int length;
{
(tclStubsPtr->tcl_SetByteArrayObj)(objPtr, bytes, length);
}
void
Tcl_SetDoubleObj(objPtr, doubleValue)
Tcl_Obj * objPtr;
double doubleValue;
{
(tclStubsPtr->tcl_SetDoubleObj)(objPtr, doubleValue);
}
void
Tcl_SetIntObj(objPtr, intValue)
Tcl_Obj * objPtr;
int intValue;
{
(tclStubsPtr->tcl_SetIntObj)(objPtr, intValue);
}
void
Tcl_SetListObj(objPtr, objc, objv)
Tcl_Obj * objPtr;
int objc;
Tcl_Obj *CONST objv[];
{
(tclStubsPtr->tcl_SetListObj)(objPtr, objc, objv);
}
void
Tcl_SetLongObj(objPtr, longValue)
Tcl_Obj * objPtr;
long longValue;
{
(tclStubsPtr->tcl_SetLongObj)(objPtr, longValue);
}
void
Tcl_SetObjLength(objPtr, length)
Tcl_Obj * objPtr;
int length;
{
(tclStubsPtr->tcl_SetObjLength)(objPtr, length);
}
void
Tcl_SetStringObj(objPtr, bytes, length)
Tcl_Obj * objPtr;
char * bytes;
int length;
{
(tclStubsPtr->tcl_SetStringObj)(objPtr, bytes, length);
}
void
Tcl_AddErrorInfo(interp, message)
Tcl_Interp * interp;
CONST char * message;
{
(tclStubsPtr->tcl_AddErrorInfo)(interp, message);
}
void
Tcl_AddObjErrorInfo(interp, message, length)
Tcl_Interp * interp;
CONST char * message;
int length;
{
(tclStubsPtr->tcl_AddObjErrorInfo)(interp, message, length);
}
void
Tcl_AllowExceptions(interp)
Tcl_Interp * interp;
{
(tclStubsPtr->tcl_AllowExceptions)(interp);
}
void
Tcl_AppendElement(interp, string)
Tcl_Interp * interp;
CONST char * string;
{
(tclStubsPtr->tcl_AppendElement)(interp, string);
}
void
Tcl_AppendResult TCL_VARARGS_DEF(Tcl_Interp *,interp)
{
Tcl_Interp * var;
va_list argList;
var = (Tcl_Interp *) TCL_VARARGS_START(Tcl_Interp *,interp,argList);
(tclStubsPtr->tcl_AppendResultVA)(var, argList);
va_end(argList);
}
Tcl_AsyncHandler
Tcl_AsyncCreate(proc, clientData)
Tcl_AsyncProc * proc;
ClientData clientData;
{
return (tclStubsPtr->tcl_AsyncCreate)(proc, clientData);
}
void
Tcl_AsyncDelete(async)
Tcl_AsyncHandler async;
{
(tclStubsPtr->tcl_AsyncDelete)(async);
}
int
Tcl_AsyncInvoke(interp, code)
Tcl_Interp * interp;
int code;
{
return (tclStubsPtr->tcl_AsyncInvoke)(interp, code);
}
void
Tcl_AsyncMark(async)
Tcl_AsyncHandler async;
{
(tclStubsPtr->tcl_AsyncMark)(async);
}
int
Tcl_AsyncReady()
{
return (tclStubsPtr->tcl_AsyncReady)();
}
void
Tcl_BackgroundError(interp)
Tcl_Interp * interp;
{
(tclStubsPtr->tcl_BackgroundError)(interp);
}
char
Tcl_Backslash(src, readPtr)
CONST char * src;
int * readPtr;
{
return (tclStubsPtr->tcl_Backslash)(src, readPtr);
}
int
Tcl_BadChannelOption(interp, optionName, optionList)
Tcl_Interp * interp;
char * optionName;
char * optionList;
{
return (tclStubsPtr->tcl_BadChannelOption)(interp, optionName, optionList);
}
void
Tcl_CallWhenDeleted(interp, proc, clientData)
Tcl_Interp * interp;
Tcl_InterpDeleteProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_CallWhenDeleted)(interp, proc, clientData);
}
void
Tcl_CancelIdleCall(idleProc, clientData)
Tcl_IdleProc * idleProc;
ClientData clientData;
{
(tclStubsPtr->tcl_CancelIdleCall)(idleProc, clientData);
}
int
Tcl_Close(interp, chan)
Tcl_Interp * interp;
Tcl_Channel chan;
{
return (tclStubsPtr->tcl_Close)(interp, chan);
}
int
Tcl_CommandComplete(cmd)
char * cmd;
{
return (tclStubsPtr->tcl_CommandComplete)(cmd);
}
char *
Tcl_Concat(argc, argv)
int argc;
char ** argv;
{
return (tclStubsPtr->tcl_Concat)(argc, argv);
}
int
Tcl_ConvertElement(src, dst, flags)
CONST char * src;
char * dst;
int flags;
{
return (tclStubsPtr->tcl_ConvertElement)(src, dst, flags);
}
int
Tcl_ConvertCountedElement(src, length, dst, flags)
CONST char * src;
int length;
char * dst;
int flags;
{
return (tclStubsPtr->tcl_ConvertCountedElement)(src, length, dst, flags);
}
int
Tcl_CreateAlias(slave, slaveCmd, target, targetCmd, argc, argv)
Tcl_Interp * slave;
char * slaveCmd;
Tcl_Interp * target;
char * targetCmd;
int argc;
char ** argv;
{
return (tclStubsPtr->tcl_CreateAlias)(slave, slaveCmd, target, targetCmd, argc, argv);
}
int
Tcl_CreateAliasObj(slave, slaveCmd, target, targetCmd, objc, objv)
Tcl_Interp * slave;
char * slaveCmd;
Tcl_Interp * target;
char * targetCmd;
int objc;
Tcl_Obj *CONST objv[];
{
return (tclStubsPtr->tcl_CreateAliasObj)(slave, slaveCmd, target, targetCmd, objc, objv);
}
Tcl_Channel
Tcl_CreateChannel(typePtr, chanName, instanceData, mask)
Tcl_ChannelType * typePtr;
char * chanName;
ClientData instanceData;
int mask;
{
return (tclStubsPtr->tcl_CreateChannel)(typePtr, chanName, instanceData, mask);
}
void
Tcl_CreateChannelHandler(chan, mask, proc, clientData)
Tcl_Channel chan;
int mask;
Tcl_ChannelProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_CreateChannelHandler)(chan, mask, proc, clientData);
}
void
Tcl_CreateCloseHandler(chan, proc, clientData)
Tcl_Channel chan;
Tcl_CloseProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_CreateCloseHandler)(chan, proc, clientData);
}
Tcl_Command
Tcl_CreateCommand(interp, cmdName, proc, clientData, deleteProc)
Tcl_Interp * interp;
char * cmdName;
Tcl_CmdProc * proc;
ClientData clientData;
Tcl_CmdDeleteProc * deleteProc;
{
return (tclStubsPtr->tcl_CreateCommand)(interp, cmdName, proc, clientData, deleteProc);
}
void
Tcl_CreateEventSource(setupProc, checkProc, clientData)
Tcl_EventSetupProc * setupProc;
Tcl_EventCheckProc * checkProc;
ClientData clientData;
{
(tclStubsPtr->tcl_CreateEventSource)(setupProc, checkProc, clientData);
}
void
Tcl_CreateExitHandler(proc, clientData)
Tcl_ExitProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_CreateExitHandler)(proc, clientData);
}
Tcl_Interp *
Tcl_CreateInterp()
{
return (tclStubsPtr->tcl_CreateInterp)();
}
void
Tcl_CreateMathFunc(interp, name, numArgs, argTypes, proc, clientData)
Tcl_Interp * interp;
char * name;
int numArgs;
Tcl_ValueType * argTypes;
Tcl_MathProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_CreateMathFunc)(interp, name, numArgs, argTypes, proc, clientData);
}
Tcl_Command
Tcl_CreateObjCommand(interp, cmdName, proc, clientData, deleteProc)
Tcl_Interp * interp;
char * cmdName;
Tcl_ObjCmdProc * proc;
ClientData clientData;
Tcl_CmdDeleteProc * deleteProc;
{
return (tclStubsPtr->tcl_CreateObjCommand)(interp, cmdName, proc, clientData, deleteProc);
}
Tcl_Interp *
Tcl_CreateSlave(interp, slaveName, isSafe)
Tcl_Interp * interp;
char * slaveName;
int isSafe;
{
return (tclStubsPtr->tcl_CreateSlave)(interp, slaveName, isSafe);
}
Tcl_TimerToken
Tcl_CreateTimerHandler(milliseconds, proc, clientData)
int milliseconds;
Tcl_TimerProc * proc;
ClientData clientData;
{
return (tclStubsPtr->tcl_CreateTimerHandler)(milliseconds, proc, clientData);
}
Tcl_Trace
Tcl_CreateTrace(interp, level, proc, clientData)
Tcl_Interp * interp;
int level;
Tcl_CmdTraceProc * proc;
ClientData clientData;
{
return (tclStubsPtr->tcl_CreateTrace)(interp, level, proc, clientData);
}
void
Tcl_DeleteAssocData(interp, name)
Tcl_Interp * interp;
char * name;
{
(tclStubsPtr->tcl_DeleteAssocData)(interp, name);
}
void
Tcl_DeleteChannelHandler(chan, proc, clientData)
Tcl_Channel chan;
Tcl_ChannelProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_DeleteChannelHandler)(chan, proc, clientData);
}
void
Tcl_DeleteCloseHandler(chan, proc, clientData)
Tcl_Channel chan;
Tcl_CloseProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_DeleteCloseHandler)(chan, proc, clientData);
}
int
Tcl_DeleteCommand(interp, cmdName)
Tcl_Interp * interp;
char * cmdName;
{
return (tclStubsPtr->tcl_DeleteCommand)(interp, cmdName);
}
int
Tcl_DeleteCommandFromToken(interp, command)
Tcl_Interp * interp;
Tcl_Command command;
{
return (tclStubsPtr->tcl_DeleteCommandFromToken)(interp, command);
}
void
Tcl_DeleteEvents(proc, clientData)
Tcl_EventDeleteProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_DeleteEvents)(proc, clientData);
}
void
Tcl_DeleteEventSource(setupProc, checkProc, clientData)
Tcl_EventSetupProc * setupProc;
Tcl_EventCheckProc * checkProc;
ClientData clientData;
{
(tclStubsPtr->tcl_DeleteEventSource)(setupProc, checkProc, clientData);
}
void
Tcl_DeleteExitHandler(proc, clientData)
Tcl_ExitProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_DeleteExitHandler)(proc, clientData);
}
void
Tcl_DeleteHashEntry(entryPtr)
Tcl_HashEntry * entryPtr;
{
(tclStubsPtr->tcl_DeleteHashEntry)(entryPtr);
}
void
Tcl_DeleteHashTable(tablePtr)
Tcl_HashTable * tablePtr;
{
(tclStubsPtr->tcl_DeleteHashTable)(tablePtr);
}
void
Tcl_DeleteInterp(interp)
Tcl_Interp * interp;
{
(tclStubsPtr->tcl_DeleteInterp)(interp);
}
void
Tcl_DetachPids(numPids, pidPtr)
int numPids;
Tcl_Pid * pidPtr;
{
(tclStubsPtr->tcl_DetachPids)(numPids, pidPtr);
}
void
Tcl_DeleteTimerHandler(token)
Tcl_TimerToken token;
{
(tclStubsPtr->tcl_DeleteTimerHandler)(token);
}
void
Tcl_DeleteTrace(interp, trace)
Tcl_Interp * interp;
Tcl_Trace trace;
{
(tclStubsPtr->tcl_DeleteTrace)(interp, trace);
}
void
Tcl_DontCallWhenDeleted(interp, proc, clientData)
Tcl_Interp * interp;
Tcl_InterpDeleteProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_DontCallWhenDeleted)(interp, proc, clientData);
}
int
Tcl_DoOneEvent(flags)
int flags;
{
return (tclStubsPtr->tcl_DoOneEvent)(flags);
}
void
Tcl_DoWhenIdle(proc, clientData)
Tcl_IdleProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_DoWhenIdle)(proc, clientData);
}
char *
Tcl_DStringAppend(dsPtr, str, length)
Tcl_DString * dsPtr;
CONST char * str;
int length;
{
return (tclStubsPtr->tcl_DStringAppend)(dsPtr, str, length);
}
char *
Tcl_DStringAppendElement(dsPtr, string)
Tcl_DString * dsPtr;
CONST char * string;
{
return (tclStubsPtr->tcl_DStringAppendElement)(dsPtr, string);
}
void
Tcl_DStringEndSublist(dsPtr)
Tcl_DString * dsPtr;
{
(tclStubsPtr->tcl_DStringEndSublist)(dsPtr);
}
void
Tcl_DStringFree(dsPtr)
Tcl_DString * dsPtr;
{
(tclStubsPtr->tcl_DStringFree)(dsPtr);
}
void
Tcl_DStringGetResult(interp, dsPtr)
Tcl_Interp * interp;
Tcl_DString * dsPtr;
{
(tclStubsPtr->tcl_DStringGetResult)(interp, dsPtr);
}
void
Tcl_DStringInit(dsPtr)
Tcl_DString * dsPtr;
{
(tclStubsPtr->tcl_DStringInit)(dsPtr);
}
void
Tcl_DStringResult(interp, dsPtr)
Tcl_Interp * interp;
Tcl_DString * dsPtr;
{
(tclStubsPtr->tcl_DStringResult)(interp, dsPtr);
}
void
Tcl_DStringSetLength(dsPtr, length)
Tcl_DString * dsPtr;
int length;
{
(tclStubsPtr->tcl_DStringSetLength)(dsPtr, length);
}
void
Tcl_DStringStartSublist(dsPtr)
Tcl_DString * dsPtr;
{
(tclStubsPtr->tcl_DStringStartSublist)(dsPtr);
}
int
Tcl_Eof(chan)
Tcl_Channel chan;
{
return (tclStubsPtr->tcl_Eof)(chan);
}
char *
Tcl_ErrnoId()
{
return (tclStubsPtr->tcl_ErrnoId)();
}
char *
Tcl_ErrnoMsg(err)
int err;
{
return (tclStubsPtr->tcl_ErrnoMsg)(err);
}
int
Tcl_Eval(interp, string)
Tcl_Interp * interp;
char * string;
{
return (tclStubsPtr->tcl_Eval)(interp, string);
}
int
Tcl_EvalFile(interp, fileName)
Tcl_Interp * interp;
char * fileName;
{
return (tclStubsPtr->tcl_EvalFile)(interp, fileName);
}
int
Tcl_EvalObj(interp, objPtr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
{
return (tclStubsPtr->tcl_EvalObj)(interp, objPtr);
}
void
Tcl_EventuallyFree(clientData, freeProc)
ClientData clientData;
Tcl_FreeProc * freeProc;
{
(tclStubsPtr->tcl_EventuallyFree)(clientData, freeProc);
}
void
Tcl_Exit(status)
int status;
{
(tclStubsPtr->tcl_Exit)(status);
}
int
Tcl_ExposeCommand(interp, hiddenCmdToken, cmdName)
Tcl_Interp * interp;
char * hiddenCmdToken;
char * cmdName;
{
return (tclStubsPtr->tcl_ExposeCommand)(interp, hiddenCmdToken, cmdName);
}
int
Tcl_ExprBoolean(interp, str, ptr)
Tcl_Interp * interp;
char * str;
int * ptr;
{
return (tclStubsPtr->tcl_ExprBoolean)(interp, str, ptr);
}
int
Tcl_ExprBooleanObj(interp, objPtr, ptr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
int * ptr;
{
return (tclStubsPtr->tcl_ExprBooleanObj)(interp, objPtr, ptr);
}
int
Tcl_ExprDouble(interp, str, ptr)
Tcl_Interp * interp;
char * str;
double * ptr;
{
return (tclStubsPtr->tcl_ExprDouble)(interp, str, ptr);
}
int
Tcl_ExprDoubleObj(interp, objPtr, ptr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
double * ptr;
{
return (tclStubsPtr->tcl_ExprDoubleObj)(interp, objPtr, ptr);
}
int
Tcl_ExprLong(interp, str, ptr)
Tcl_Interp * interp;
char * str;
long * ptr;
{
return (tclStubsPtr->tcl_ExprLong)(interp, str, ptr);
}
int
Tcl_ExprLongObj(interp, objPtr, ptr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
long * ptr;
{
return (tclStubsPtr->tcl_ExprLongObj)(interp, objPtr, ptr);
}
int
Tcl_ExprObj(interp, objPtr, resultPtrPtr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
Tcl_Obj ** resultPtrPtr;
{
return (tclStubsPtr->tcl_ExprObj)(interp, objPtr, resultPtrPtr);
}
int
Tcl_ExprString(interp, string)
Tcl_Interp * interp;
char * string;
{
return (tclStubsPtr->tcl_ExprString)(interp, string);
}
void
Tcl_Finalize()
{
(tclStubsPtr->tcl_Finalize)();
}
void
Tcl_FindExecutable(argv0)
CONST char * argv0;
{
(tclStubsPtr->tcl_FindExecutable)(argv0);
}
Tcl_HashEntry *
Tcl_FirstHashEntry(tablePtr, searchPtr)
Tcl_HashTable * tablePtr;
Tcl_HashSearch * searchPtr;
{
return (tclStubsPtr->tcl_FirstHashEntry)(tablePtr, searchPtr);
}
int
Tcl_Flush(chan)
Tcl_Channel chan;
{
return (tclStubsPtr->tcl_Flush)(chan);
}
void
Tcl_FreeResult(interp)
Tcl_Interp * interp;
{
(tclStubsPtr->tcl_FreeResult)(interp);
}
int
Tcl_GetAlias(interp, slaveCmd, targetInterpPtr, targetCmdPtr, argcPtr, argvPtr)
Tcl_Interp * interp;
char * slaveCmd;
Tcl_Interp ** targetInterpPtr;
char ** targetCmdPtr;
int * argcPtr;
char *** argvPtr;
{
return (tclStubsPtr->tcl_GetAlias)(interp, slaveCmd, targetInterpPtr, targetCmdPtr, argcPtr, argvPtr);
}
int
Tcl_GetAliasObj(interp, slaveCmd, targetInterpPtr, targetCmdPtr, objcPtr, objv)
Tcl_Interp * interp;
char * slaveCmd;
Tcl_Interp ** targetInterpPtr;
char ** targetCmdPtr;
int * objcPtr;
Tcl_Obj *** objv;
{
return (tclStubsPtr->tcl_GetAliasObj)(interp, slaveCmd, targetInterpPtr, targetCmdPtr, objcPtr, objv);
}
ClientData
Tcl_GetAssocData(interp, name, procPtr)
Tcl_Interp * interp;
char * name;
Tcl_InterpDeleteProc ** procPtr;
{
return (tclStubsPtr->tcl_GetAssocData)(interp, name, procPtr);
}
Tcl_Channel
Tcl_GetChannel(interp, chanName, modePtr)
Tcl_Interp * interp;
char * chanName;
int * modePtr;
{
return (tclStubsPtr->tcl_GetChannel)(interp, chanName, modePtr);
}
int
Tcl_GetChannelBufferSize(chan)
Tcl_Channel chan;
{
return (tclStubsPtr->tcl_GetChannelBufferSize)(chan);
}
int
Tcl_GetChannelHandle(chan, direction, handlePtr)
Tcl_Channel chan;
int direction;
ClientData * handlePtr;
{
return (tclStubsPtr->tcl_GetChannelHandle)(chan, direction, handlePtr);
}
ClientData
Tcl_GetChannelInstanceData(chan)
Tcl_Channel chan;
{
return (tclStubsPtr->tcl_GetChannelInstanceData)(chan);
}
int
Tcl_GetChannelMode(chan)
Tcl_Channel chan;
{
return (tclStubsPtr->tcl_GetChannelMode)(chan);
}
char *
Tcl_GetChannelName(chan)
Tcl_Channel chan;
{
return (tclStubsPtr->tcl_GetChannelName)(chan);
}
int
Tcl_GetChannelOption(interp, chan, optionName, dsPtr)
Tcl_Interp * interp;
Tcl_Channel chan;
char * optionName;
Tcl_DString * dsPtr;
{
return (tclStubsPtr->tcl_GetChannelOption)(interp, chan, optionName, dsPtr);
}
Tcl_ChannelType *
Tcl_GetChannelType(chan)
Tcl_Channel chan;
{
return (tclStubsPtr->tcl_GetChannelType)(chan);
}
int
Tcl_GetCommandInfo(interp, cmdName, infoPtr)
Tcl_Interp * interp;
char * cmdName;
Tcl_CmdInfo * infoPtr;
{
return (tclStubsPtr->tcl_GetCommandInfo)(interp, cmdName, infoPtr);
}
char *
Tcl_GetCommandName(interp, command)
Tcl_Interp * interp;
Tcl_Command command;
{
return (tclStubsPtr->tcl_GetCommandName)(interp, command);
}
int
Tcl_GetErrno()
{
return (tclStubsPtr->tcl_GetErrno)();
}
char *
Tcl_GetHostName()
{
return (tclStubsPtr->tcl_GetHostName)();
}
int
Tcl_GetInterpPath(askInterp, slaveInterp)
Tcl_Interp * askInterp;
Tcl_Interp * slaveInterp;
{
return (tclStubsPtr->tcl_GetInterpPath)(askInterp, slaveInterp);
}
Tcl_Interp *
Tcl_GetMaster(interp)
Tcl_Interp * interp;
{
return (tclStubsPtr->tcl_GetMaster)(interp);
}
CONST char *
Tcl_GetNameOfExecutable()
{
return (tclStubsPtr->tcl_GetNameOfExecutable)();
}
Tcl_Obj *
Tcl_GetObjResult(interp)
Tcl_Interp * interp;
{
return (tclStubsPtr->tcl_GetObjResult)(interp);
}
#if !defined(__WIN32__) && !defined(MAC_TCL)
int
Tcl_GetOpenFile(interp, str, write, checkUsage, filePtr)
Tcl_Interp * interp;
char * str;
int write;
int checkUsage;
ClientData * filePtr;
{
return (tclStubsPtr->tcl_GetOpenFile)(interp, str, write, checkUsage, filePtr);
}
#endif
Tcl_PathType
Tcl_GetPathType(path)
char * path;
{
return (tclStubsPtr->tcl_GetPathType)(path);
}
int
Tcl_Gets(chan, dsPtr)
Tcl_Channel chan;
Tcl_DString * dsPtr;
{
return (tclStubsPtr->tcl_Gets)(chan, dsPtr);
}
int
Tcl_GetsObj(chan, objPtr)
Tcl_Channel chan;
Tcl_Obj * objPtr;
{
return (tclStubsPtr->tcl_GetsObj)(chan, objPtr);
}
int
Tcl_GetServiceMode()
{
return (tclStubsPtr->tcl_GetServiceMode)();
}
Tcl_Interp *
Tcl_GetSlave(interp, slaveName)
Tcl_Interp * interp;
char * slaveName;
{
return (tclStubsPtr->tcl_GetSlave)(interp, slaveName);
}
Tcl_Channel
Tcl_GetStdChannel(type)
int type;
{
return (tclStubsPtr->tcl_GetStdChannel)(type);
}
char *
Tcl_GetStringResult(interp)
Tcl_Interp * interp;
{
return (tclStubsPtr->tcl_GetStringResult)(interp);
}
char *
Tcl_GetVar(interp, varName, flags)
Tcl_Interp * interp;
char * varName;
int flags;
{
return (tclStubsPtr->tcl_GetVar)(interp, varName, flags);
}
char *
Tcl_GetVar2(interp, part1, part2, flags)
Tcl_Interp * interp;
char * part1;
char * part2;
int flags;
{
return (tclStubsPtr->tcl_GetVar2)(interp, part1, part2, flags);
}
int
Tcl_GlobalEval(interp, command)
Tcl_Interp * interp;
char * command;
{
return (tclStubsPtr->tcl_GlobalEval)(interp, command);
}
int
Tcl_GlobalEvalObj(interp, objPtr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
{
return (tclStubsPtr->tcl_GlobalEvalObj)(interp, objPtr);
}
int
Tcl_HideCommand(interp, cmdName, hiddenCmdToken)
Tcl_Interp * interp;
char * cmdName;
char * hiddenCmdToken;
{
return (tclStubsPtr->tcl_HideCommand)(interp, cmdName, hiddenCmdToken);
}
int
Tcl_Init(interp)
Tcl_Interp * interp;
{
return (tclStubsPtr->tcl_Init)(interp);
}
void
Tcl_InitHashTable(tablePtr, keyType)
Tcl_HashTable * tablePtr;
int keyType;
{
(tclStubsPtr->tcl_InitHashTable)(tablePtr, keyType);
}
int
Tcl_InputBlocked(chan)
Tcl_Channel chan;
{
return (tclStubsPtr->tcl_InputBlocked)(chan);
}
int
Tcl_InputBuffered(chan)
Tcl_Channel chan;
{
return (tclStubsPtr->tcl_InputBuffered)(chan);
}
int
Tcl_InterpDeleted(interp)
Tcl_Interp * interp;
{
return (tclStubsPtr->tcl_InterpDeleted)(interp);
}
int
Tcl_IsSafe(interp)
Tcl_Interp * interp;
{
return (tclStubsPtr->tcl_IsSafe)(interp);
}
char *
Tcl_JoinPath(argc, argv, resultPtr)
int argc;
CONST char ** argv;
Tcl_DString * resultPtr;
{
return (tclStubsPtr->tcl_JoinPath)(argc, argv, resultPtr);
}
int
Tcl_LinkVar(interp, varName, addr, type)
Tcl_Interp * interp;
char * varName;
char * addr;
int type;
{
return (tclStubsPtr->tcl_LinkVar)(interp, varName, addr, type);
}
Tcl_Channel
Tcl_MakeFileChannel(handle, mode)
ClientData handle;
int mode;
{
return (tclStubsPtr->tcl_MakeFileChannel)(handle, mode);
}
int
Tcl_MakeSafe(interp)
Tcl_Interp * interp;
{
return (tclStubsPtr->tcl_MakeSafe)(interp);
}
Tcl_Channel
Tcl_MakeTcpClientChannel(tcpSocket)
ClientData tcpSocket;
{
return (tclStubsPtr->tcl_MakeTcpClientChannel)(tcpSocket);
}
char *
Tcl_Merge(argc, argv)
int argc;
char ** argv;
{
return (tclStubsPtr->tcl_Merge)(argc, argv);
}
Tcl_HashEntry *
Tcl_NextHashEntry(searchPtr)
Tcl_HashSearch * searchPtr;
{
return (tclStubsPtr->tcl_NextHashEntry)(searchPtr);
}
void
Tcl_NotifyChannel(channel, mask)
Tcl_Channel channel;
int mask;
{
(tclStubsPtr->tcl_NotifyChannel)(channel, mask);
}
Tcl_Obj *
Tcl_ObjGetVar2(interp, part1Ptr, part2Ptr, flags)
Tcl_Interp * interp;
Tcl_Obj * part1Ptr;
Tcl_Obj * part2Ptr;
int flags;
{
return (tclStubsPtr->tcl_ObjGetVar2)(interp, part1Ptr, part2Ptr, flags);
}
Tcl_Obj *
Tcl_ObjSetVar2(interp, part1Ptr, part2Ptr, newValuePtr, flags)
Tcl_Interp * interp;
Tcl_Obj * part1Ptr;
Tcl_Obj * part2Ptr;
Tcl_Obj * newValuePtr;
int flags;
{
return (tclStubsPtr->tcl_ObjSetVar2)(interp, part1Ptr, part2Ptr, newValuePtr, flags);
}
Tcl_Channel
Tcl_OpenCommandChannel(interp, argc, argv, flags)
Tcl_Interp * interp;
int argc;
char ** argv;
int flags;
{
return (tclStubsPtr->tcl_OpenCommandChannel)(interp, argc, argv, flags);
}
Tcl_Channel
Tcl_OpenFileChannel(interp, fileName, modeString, permissions)
Tcl_Interp * interp;
char * fileName;
char * modeString;
int permissions;
{
return (tclStubsPtr->tcl_OpenFileChannel)(interp, fileName, modeString, permissions);
}
Tcl_Channel
Tcl_OpenTcpClient(interp, port, address, myaddr, myport, async)
Tcl_Interp * interp;
int port;
char * address;
char * myaddr;
int myport;
int async;
{
return (tclStubsPtr->tcl_OpenTcpClient)(interp, port, address, myaddr, myport, async);
}
Tcl_Channel
Tcl_OpenTcpServer(interp, port, host, acceptProc, callbackData)
Tcl_Interp * interp;
int port;
char * host;
Tcl_TcpAcceptProc * acceptProc;
ClientData callbackData;
{
return (tclStubsPtr->tcl_OpenTcpServer)(interp, port, host, acceptProc, callbackData);
}
void
Tcl_Preserve(data)
ClientData data;
{
(tclStubsPtr->tcl_Preserve)(data);
}
void
Tcl_PrintDouble(interp, value, dst)
Tcl_Interp * interp;
double value;
char * dst;
{
(tclStubsPtr->tcl_PrintDouble)(interp, value, dst);
}
int
Tcl_PutEnv(string)
CONST char * string;
{
return (tclStubsPtr->tcl_PutEnv)(string);
}
char *
Tcl_PosixError(interp)
Tcl_Interp * interp;
{
return (tclStubsPtr->tcl_PosixError)(interp);
}
void
Tcl_QueueEvent(evPtr, position)
Tcl_Event * evPtr;
Tcl_QueuePosition position;
{
(tclStubsPtr->tcl_QueueEvent)(evPtr, position);
}
int
Tcl_Read(chan, bufPtr, toRead)
Tcl_Channel chan;
char * bufPtr;
int toRead;
{
return (tclStubsPtr->tcl_Read)(chan, bufPtr, toRead);
}
void
Tcl_ReapDetachedProcs()
{
(tclStubsPtr->tcl_ReapDetachedProcs)();
}
int
Tcl_RecordAndEval(interp, cmd, flags)
Tcl_Interp * interp;
char * cmd;
int flags;
{
return (tclStubsPtr->tcl_RecordAndEval)(interp, cmd, flags);
}
int
Tcl_RecordAndEvalObj(interp, cmdPtr, flags)
Tcl_Interp * interp;
Tcl_Obj * cmdPtr;
int flags;
{
return (tclStubsPtr->tcl_RecordAndEvalObj)(interp, cmdPtr, flags);
}
void
Tcl_RegisterChannel(interp, chan)
Tcl_Interp * interp;
Tcl_Channel chan;
{
(tclStubsPtr->tcl_RegisterChannel)(interp, chan);
}
void
Tcl_RegisterObjType(typePtr)
Tcl_ObjType * typePtr;
{
(tclStubsPtr->tcl_RegisterObjType)(typePtr);
}
Tcl_RegExp
Tcl_RegExpCompile(interp, string)
Tcl_Interp * interp;
char * string;
{
return (tclStubsPtr->tcl_RegExpCompile)(interp, string);
}
int
Tcl_RegExpExec(interp, regexp, str, start)
Tcl_Interp * interp;
Tcl_RegExp regexp;
CONST char * str;
CONST char * start;
{
return (tclStubsPtr->tcl_RegExpExec)(interp, regexp, str, start);
}
int
Tcl_RegExpMatch(interp, str, pattern)
Tcl_Interp * interp;
char * str;
char * pattern;
{
return (tclStubsPtr->tcl_RegExpMatch)(interp, str, pattern);
}
void
Tcl_RegExpRange(regexp, index, startPtr, endPtr)
Tcl_RegExp regexp;
int index;
char ** startPtr;
char ** endPtr;
{
(tclStubsPtr->tcl_RegExpRange)(regexp, index, startPtr, endPtr);
}
void
Tcl_Release(clientData)
ClientData clientData;
{
(tclStubsPtr->tcl_Release)(clientData);
}
void
Tcl_ResetResult(interp)
Tcl_Interp * interp;
{
(tclStubsPtr->tcl_ResetResult)(interp);
}
int
Tcl_ScanElement(str, flagPtr)
CONST char * str;
int * flagPtr;
{
return (tclStubsPtr->tcl_ScanElement)(str, flagPtr);
}
int
Tcl_ScanCountedElement(str, length, flagPtr)
CONST char * str;
int length;
int * flagPtr;
{
return (tclStubsPtr->tcl_ScanCountedElement)(str, length, flagPtr);
}
int
Tcl_Seek(chan, offset, mode)
Tcl_Channel chan;
int offset;
int mode;
{
return (tclStubsPtr->tcl_Seek)(chan, offset, mode);
}
int
Tcl_ServiceAll()
{
return (tclStubsPtr->tcl_ServiceAll)();
}
int
Tcl_ServiceEvent(flags)
int flags;
{
return (tclStubsPtr->tcl_ServiceEvent)(flags);
}
void
Tcl_SetAssocData(interp, name, proc, clientData)
Tcl_Interp * interp;
char * name;
Tcl_InterpDeleteProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_SetAssocData)(interp, name, proc, clientData);
}
void
Tcl_SetChannelBufferSize(chan, sz)
Tcl_Channel chan;
int sz;
{
(tclStubsPtr->tcl_SetChannelBufferSize)(chan, sz);
}
int
Tcl_SetChannelOption(interp, chan, optionName, newValue)
Tcl_Interp * interp;
Tcl_Channel chan;
char * optionName;
char * newValue;
{
return (tclStubsPtr->tcl_SetChannelOption)(interp, chan, optionName, newValue);
}
int
Tcl_SetCommandInfo(interp, cmdName, infoPtr)
Tcl_Interp * interp;
char * cmdName;
Tcl_CmdInfo * infoPtr;
{
return (tclStubsPtr->tcl_SetCommandInfo)(interp, cmdName, infoPtr);
}
void
Tcl_SetErrno(err)
int err;
{
(tclStubsPtr->tcl_SetErrno)(err);
}
void
Tcl_SetErrorCode TCL_VARARGS_DEF(Tcl_Interp *,interp)
{
Tcl_Interp * var;
va_list argList;
var = (Tcl_Interp *) TCL_VARARGS_START(Tcl_Interp *,interp,argList);
(tclStubsPtr->tcl_SetErrorCodeVA)(var, argList);
va_end(argList);
}
void
Tcl_SetMaxBlockTime(timePtr)
Tcl_Time * timePtr;
{
(tclStubsPtr->tcl_SetMaxBlockTime)(timePtr);
}
void
Tcl_SetPanicProc(panicProc)
Tcl_PanicProc * panicProc;
{
(tclStubsPtr->tcl_SetPanicProc)(panicProc);
}
int
Tcl_SetRecursionLimit(interp, depth)
Tcl_Interp * interp;
int depth;
{
return (tclStubsPtr->tcl_SetRecursionLimit)(interp, depth);
}
void
Tcl_SetResult(interp, str, freeProc)
Tcl_Interp * interp;
char * str;
Tcl_FreeProc * freeProc;
{
(tclStubsPtr->tcl_SetResult)(interp, str, freeProc);
}
int
Tcl_SetServiceMode(mode)
int mode;
{
return (tclStubsPtr->tcl_SetServiceMode)(mode);
}
void
Tcl_SetObjErrorCode(interp, errorObjPtr)
Tcl_Interp * interp;
Tcl_Obj * errorObjPtr;
{
(tclStubsPtr->tcl_SetObjErrorCode)(interp, errorObjPtr);
}
void
Tcl_SetObjResult(interp, resultObjPtr)
Tcl_Interp * interp;
Tcl_Obj * resultObjPtr;
{
(tclStubsPtr->tcl_SetObjResult)(interp, resultObjPtr);
}
void
Tcl_SetStdChannel(channel, type)
Tcl_Channel channel;
int type;
{
(tclStubsPtr->tcl_SetStdChannel)(channel, type);
}
char *
Tcl_SetVar(interp, varName, newValue, flags)
Tcl_Interp * interp;
char * varName;
char * newValue;
int flags;
{
return (tclStubsPtr->tcl_SetVar)(interp, varName, newValue, flags);
}
char *
Tcl_SetVar2(interp, part1, part2, newValue, flags)
Tcl_Interp * interp;
char * part1;
char * part2;
char * newValue;
int flags;
{
return (tclStubsPtr->tcl_SetVar2)(interp, part1, part2, newValue, flags);
}
char *
Tcl_SignalId(sig)
int sig;
{
return (tclStubsPtr->tcl_SignalId)(sig);
}
char *
Tcl_SignalMsg(sig)
int sig;
{
return (tclStubsPtr->tcl_SignalMsg)(sig);
}
void
Tcl_SourceRCFile(interp)
Tcl_Interp * interp;
{
(tclStubsPtr->tcl_SourceRCFile)(interp);
}
int
Tcl_SplitList(interp, listStr, argcPtr, argvPtr)
Tcl_Interp * interp;
CONST char * listStr;
int * argcPtr;
char *** argvPtr;
{
return (tclStubsPtr->tcl_SplitList)(interp, listStr, argcPtr, argvPtr);
}
void
Tcl_SplitPath(path, argcPtr, argvPtr)
CONST char * path;
int * argcPtr;
char *** argvPtr;
{
(tclStubsPtr->tcl_SplitPath)(path, argcPtr, argvPtr);
}
void
Tcl_StaticPackage(interp, pkgName, initProc, safeInitProc)
Tcl_Interp * interp;
char * pkgName;
Tcl_PackageInitProc * initProc;
Tcl_PackageInitProc * safeInitProc;
{
(tclStubsPtr->tcl_StaticPackage)(interp, pkgName, initProc, safeInitProc);
}
int
Tcl_StringMatch(str, pattern)
CONST char * str;
CONST char * pattern;
{
return (tclStubsPtr->tcl_StringMatch)(str, pattern);
}
int
Tcl_Tell(chan)
Tcl_Channel chan;
{
return (tclStubsPtr->tcl_Tell)(chan);
}
int
Tcl_TraceVar(interp, varName, flags, proc, clientData)
Tcl_Interp * interp;
char * varName;
int flags;
Tcl_VarTraceProc * proc;
ClientData clientData;
{
return (tclStubsPtr->tcl_TraceVar)(interp, varName, flags, proc, clientData);
}
int
Tcl_TraceVar2(interp, part1, part2, flags, proc, clientData)
Tcl_Interp * interp;
char * part1;
char * part2;
int flags;
Tcl_VarTraceProc * proc;
ClientData clientData;
{
return (tclStubsPtr->tcl_TraceVar2)(interp, part1, part2, flags, proc, clientData);
}
char *
Tcl_TranslateFileName(interp, name, bufferPtr)
Tcl_Interp * interp;
CONST char * name;
Tcl_DString * bufferPtr;
{
return (tclStubsPtr->tcl_TranslateFileName)(interp, name, bufferPtr);
}
int
Tcl_Ungets(chan, str, len, atHead)
Tcl_Channel chan;
char * str;
int len;
int atHead;
{
return (tclStubsPtr->tcl_Ungets)(chan, str, len, atHead);
}
void
Tcl_UnlinkVar(interp, varName)
Tcl_Interp * interp;
char * varName;
{
(tclStubsPtr->tcl_UnlinkVar)(interp, varName);
}
int
Tcl_UnregisterChannel(interp, chan)
Tcl_Interp * interp;
Tcl_Channel chan;
{
return (tclStubsPtr->tcl_UnregisterChannel)(interp, chan);
}
int
Tcl_UnsetVar(interp, varName, flags)
Tcl_Interp * interp;
char * varName;
int flags;
{
return (tclStubsPtr->tcl_UnsetVar)(interp, varName, flags);
}
int
Tcl_UnsetVar2(interp, part1, part2, flags)
Tcl_Interp * interp;
char * part1;
char * part2;
int flags;
{
return (tclStubsPtr->tcl_UnsetVar2)(interp, part1, part2, flags);
}
void
Tcl_UntraceVar(interp, varName, flags, proc, clientData)
Tcl_Interp * interp;
char * varName;
int flags;
Tcl_VarTraceProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_UntraceVar)(interp, varName, flags, proc, clientData);
}
void
Tcl_UntraceVar2(interp, part1, part2, flags, proc, clientData)
Tcl_Interp * interp;
char * part1;
char * part2;
int flags;
Tcl_VarTraceProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_UntraceVar2)(interp, part1, part2, flags, proc, clientData);
}
void
Tcl_UpdateLinkedVar(interp, varName)
Tcl_Interp * interp;
char * varName;
{
(tclStubsPtr->tcl_UpdateLinkedVar)(interp, varName);
}
int
Tcl_UpVar(interp, frameName, varName, localName, flags)
Tcl_Interp * interp;
char * frameName;
char * varName;
char * localName;
int flags;
{
return (tclStubsPtr->tcl_UpVar)(interp, frameName, varName, localName, flags);
}
int
Tcl_UpVar2(interp, frameName, part1, part2, localName, flags)
Tcl_Interp * interp;
char * frameName;
char * part1;
char * part2;
char * localName;
int flags;
{
return (tclStubsPtr->tcl_UpVar2)(interp, frameName, part1, part2, localName, flags);
}
int
Tcl_VarEval TCL_VARARGS_DEF(Tcl_Interp *,interp)
{
Tcl_Interp * var;
va_list argList;
int resultValue;
var = (Tcl_Interp *) TCL_VARARGS_START(Tcl_Interp *,interp,argList);
resultValue = (tclStubsPtr->tcl_VarEvalVA)(var, argList);
va_end(argList);
return resultValue;
}
ClientData
Tcl_VarTraceInfo(interp, varName, flags, procPtr, prevClientData)
Tcl_Interp * interp;
char * varName;
int flags;
Tcl_VarTraceProc * procPtr;
ClientData prevClientData;
{
return (tclStubsPtr->tcl_VarTraceInfo)(interp, varName, flags, procPtr, prevClientData);
}
ClientData
Tcl_VarTraceInfo2(interp, part1, part2, flags, procPtr, prevClientData)
Tcl_Interp * interp;
char * part1;
char * part2;
int flags;
Tcl_VarTraceProc * procPtr;
ClientData prevClientData;
{
return (tclStubsPtr->tcl_VarTraceInfo2)(interp, part1, part2, flags, procPtr, prevClientData);
}
int
Tcl_Write(chan, s, slen)
Tcl_Channel chan;
char * s;
int slen;
{
return (tclStubsPtr->tcl_Write)(chan, s, slen);
}
void
Tcl_WrongNumArgs(interp, objc, objv, message)
Tcl_Interp * interp;
int objc;
Tcl_Obj *CONST objv[];
char * message;
{
(tclStubsPtr->tcl_WrongNumArgs)(interp, objc, objv, message);
}
int
Tcl_DumpActiveMemory(fileName)
char * fileName;
{
return (tclStubsPtr->tcl_DumpActiveMemory)(fileName);
}
void
Tcl_ValidateAllMemory(file, line)
char * file;
int line;
{
(tclStubsPtr->tcl_ValidateAllMemory)(file, line);
}
void
Tcl_AppendResultVA(interp, argList)
Tcl_Interp * interp;
va_list argList;
{
(tclStubsPtr->tcl_AppendResultVA)(interp, argList);
}
void
Tcl_AppendStringsToObjVA(objPtr, argList)
Tcl_Obj * objPtr;
va_list argList;
{
(tclStubsPtr->tcl_AppendStringsToObjVA)(objPtr, argList);
}
char *
Tcl_HashStats(tablePtr)
Tcl_HashTable * tablePtr;
{
return (tclStubsPtr->tcl_HashStats)(tablePtr);
}
char *
Tcl_ParseVar(interp, str, termPtr)
Tcl_Interp * interp;
char * str;
char ** termPtr;
{
return (tclStubsPtr->tcl_ParseVar)(interp, str, termPtr);
}
char *
Tcl_PkgPresent(interp, name, version, exact)
Tcl_Interp * interp;
char * name;
char * version;
int exact;
{
return (tclStubsPtr->tcl_PkgPresent)(interp, name, version, exact);
}
char *
Tcl_PkgPresentEx(interp, name, version, exact, clientDataPtr)
Tcl_Interp * interp;
char * name;
char * version;
int exact;
ClientData * clientDataPtr;
{
return (tclStubsPtr->tcl_PkgPresentEx)(interp, name, version, exact, clientDataPtr);
}
int
Tcl_PkgProvide(interp, name, version)
Tcl_Interp * interp;
char * name;
char * version;
{
return (tclStubsPtr->tcl_PkgProvide)(interp, name, version);
}
char *
Tcl_PkgRequire(interp, name, version, exact)
Tcl_Interp * interp;
char * name;
char * version;
int exact;
{
return (tclStubsPtr->tcl_PkgRequire)(interp, name, version, exact);
}
void
Tcl_SetErrorCodeVA(interp, argList)
Tcl_Interp * interp;
va_list argList;
{
(tclStubsPtr->tcl_SetErrorCodeVA)(interp, argList);
}
int
Tcl_VarEvalVA(interp, argList)
Tcl_Interp * interp;
va_list argList;
{
return (tclStubsPtr->tcl_VarEvalVA)(interp, argList);
}
Tcl_Pid
Tcl_WaitPid(pid, statPtr, options)
Tcl_Pid pid;
int * statPtr;
int options;
{
return (tclStubsPtr->tcl_WaitPid)(pid, statPtr, options);
}
void
Tcl_PanicVA(format, argList)
char * format;
va_list argList;
{
(tclStubsPtr->tcl_PanicVA)(format, argList);
}
void
Tcl_GetVersion(major, minor, patchLevel, type)
int * major;
int * minor;
int * patchLevel;
int * type;
{
(tclStubsPtr->tcl_GetVersion)(major, minor, patchLevel, type);
}
void
Tcl_AppendObjToObj(objPtr, appendObjPtr)
Tcl_Obj * objPtr;
Tcl_Obj * appendObjPtr;
{
(tclStubsPtr->tcl_AppendObjToObj)(objPtr, appendObjPtr);
}
Tcl_Encoding
Tcl_CreateEncoding(typePtr)
Tcl_EncodingType * typePtr;
{
return (tclStubsPtr->tcl_CreateEncoding)(typePtr);
}
void
Tcl_CreateThreadExitHandler(proc, clientData)
Tcl_ExitProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_CreateThreadExitHandler)(proc, clientData);
}
void
Tcl_DeleteThreadExitHandler(proc, clientData)
Tcl_ExitProc * proc;
ClientData clientData;
{
(tclStubsPtr->tcl_DeleteThreadExitHandler)(proc, clientData);
}
void
Tcl_DiscardResult(statePtr)
Tcl_SavedResult * statePtr;
{
(tclStubsPtr->tcl_DiscardResult)(statePtr);
}
int
Tcl_EvalEx(interp, script, numBytes, flags)
Tcl_Interp * interp;
char * script;
int numBytes;
int flags;
{
return (tclStubsPtr->tcl_EvalEx)(interp, script, numBytes, flags);
}
int
Tcl_EvalObjv(interp, objc, objv, flags)
Tcl_Interp * interp;
int objc;
Tcl_Obj *CONST objv[];
int flags;
{
return (tclStubsPtr->tcl_EvalObjv)(interp, objc, objv, flags);
}
int
Tcl_EvalObjEx(interp, objPtr, flags)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
int flags;
{
return (tclStubsPtr->tcl_EvalObjEx)(interp, objPtr, flags);
}
void
Tcl_ExitThread(status)
int status;
{
(tclStubsPtr->tcl_ExitThread)(status);
}
int
Tcl_ExternalToUtf(interp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr)
Tcl_Interp * interp;
Tcl_Encoding encoding;
CONST char * src;
int srcLen;
int flags;
Tcl_EncodingState * statePtr;
char * dst;
int dstLen;
int * srcReadPtr;
int * dstWrotePtr;
int * dstCharsPtr;
{
return (tclStubsPtr->tcl_ExternalToUtf)(interp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr);
}
char *
Tcl_ExternalToUtfDString(encoding, src, srcLen, dsPtr)
Tcl_Encoding encoding;
CONST char * src;
int srcLen;
Tcl_DString * dsPtr;
{
return (tclStubsPtr->tcl_ExternalToUtfDString)(encoding, src, srcLen, dsPtr);
}
void
Tcl_FinalizeThread()
{
(tclStubsPtr->tcl_FinalizeThread)();
}
void
Tcl_FinalizeNotifier(clientData)
ClientData clientData;
{
(tclStubsPtr->tcl_FinalizeNotifier)(clientData);
}
void
Tcl_FreeEncoding(encoding)
Tcl_Encoding encoding;
{
(tclStubsPtr->tcl_FreeEncoding)(encoding);
}
Tcl_ThreadId
Tcl_GetCurrentThread()
{
return (tclStubsPtr->tcl_GetCurrentThread)();
}
Tcl_Encoding
Tcl_GetEncoding(interp, name)
Tcl_Interp * interp;
CONST char * name;
{
return (tclStubsPtr->tcl_GetEncoding)(interp, name);
}
char *
Tcl_GetEncodingName(encoding)
Tcl_Encoding encoding;
{
return (tclStubsPtr->tcl_GetEncodingName)(encoding);
}
void
Tcl_GetEncodingNames(interp)
Tcl_Interp * interp;
{
(tclStubsPtr->tcl_GetEncodingNames)(interp);
}
int
Tcl_GetIndexFromObjStruct(interp, objPtr, tablePtr, offset, msg, flags, indexPtr)
Tcl_Interp * interp;
Tcl_Obj * objPtr;
char ** tablePtr;
int offset;
char * msg;
int flags;
int * indexPtr;
{
return (tclStubsPtr->tcl_GetIndexFromObjStruct)(interp, objPtr, tablePtr, offset, msg, flags, indexPtr);
}
VOID *
Tcl_GetThreadData(keyPtr, size)
Tcl_ThreadDataKey * keyPtr;
int size;
{
return (tclStubsPtr->tcl_GetThreadData)(keyPtr, size);
}
Tcl_Obj *
Tcl_GetVar2Ex(interp, part1, part2, flags)
Tcl_Interp * interp;
char * part1;
char * part2;
int flags;
{
return (tclStubsPtr->tcl_GetVar2Ex)(interp, part1, part2, flags);
}
ClientData
Tcl_InitNotifier()
{
return (tclStubsPtr->tcl_InitNotifier)();
}
void
Tcl_MutexLock(mutexPtr)
Tcl_Mutex * mutexPtr;
{
(tclStubsPtr->tcl_MutexLock)(mutexPtr);
}
void
Tcl_MutexUnlock(mutexPtr)
Tcl_Mutex * mutexPtr;
{
(tclStubsPtr->tcl_MutexUnlock)(mutexPtr);
}
void
Tcl_ConditionNotify(condPtr)
Tcl_Condition * condPtr;
{
(tclStubsPtr->tcl_ConditionNotify)(condPtr);
}
void
Tcl_ConditionWait(condPtr, mutexPtr, timePtr)
Tcl_Condition * condPtr;
Tcl_Mutex * mutexPtr;
Tcl_Time * timePtr;
{
(tclStubsPtr->tcl_ConditionWait)(condPtr, mutexPtr, timePtr);
}
int
Tcl_NumUtfChars(src, len)
CONST char * src;
int len;
{
return (tclStubsPtr->tcl_NumUtfChars)(src, len);
}
int
Tcl_ReadChars(channel, objPtr, charsToRead, appendFlag)
Tcl_Channel channel;
Tcl_Obj * objPtr;
int charsToRead;
int appendFlag;
{
return (tclStubsPtr->tcl_ReadChars)(channel, objPtr, charsToRead, appendFlag);
}
void
Tcl_RestoreResult(interp, statePtr)
Tcl_Interp * interp;
Tcl_SavedResult * statePtr;
{
(tclStubsPtr->tcl_RestoreResult)(interp, statePtr);
}
void
Tcl_SaveResult(interp, statePtr)
Tcl_Interp * interp;
Tcl_SavedResult * statePtr;
{
(tclStubsPtr->tcl_SaveResult)(interp, statePtr);
}
int
Tcl_SetSystemEncoding(interp, name)
Tcl_Interp * interp;
CONST char * name;
{
return (tclStubsPtr->tcl_SetSystemEncoding)(interp, name);
}
Tcl_Obj *
Tcl_SetVar2Ex(interp, part1, part2, newValuePtr, flags)
Tcl_Interp * interp;
char * part1;
char * part2;
Tcl_Obj * newValuePtr;
int flags;
{
return (tclStubsPtr->tcl_SetVar2Ex)(interp, part1, part2, newValuePtr, flags);
}
void
Tcl_ThreadAlert(threadId)
Tcl_ThreadId threadId;
{
(tclStubsPtr->tcl_ThreadAlert)(threadId);
}
void
Tcl_ThreadQueueEvent(threadId, evPtr, position)
Tcl_ThreadId threadId;
Tcl_Event* evPtr;
Tcl_QueuePosition position;
{
(tclStubsPtr->tcl_ThreadQueueEvent)(threadId, evPtr, position);
}
Tcl_UniChar
Tcl_UniCharAtIndex(src, index)
CONST char * src;
int index;
{
return (tclStubsPtr->tcl_UniCharAtIndex)(src, index);
}
Tcl_UniChar
Tcl_UniCharToLower(ch)
int ch;
{
return (tclStubsPtr->tcl_UniCharToLower)(ch);
}
Tcl_UniChar
Tcl_UniCharToTitle(ch)
int ch;
{
return (tclStubsPtr->tcl_UniCharToTitle)(ch);
}
Tcl_UniChar
Tcl_UniCharToUpper(ch)
int ch;
{
return (tclStubsPtr->tcl_UniCharToUpper)(ch);
}
int
Tcl_UniCharToUtf(ch, buf)
int ch;
char * buf;
{
return (tclStubsPtr->tcl_UniCharToUtf)(ch, buf);
}
char *
Tcl_UtfAtIndex(src, index)
CONST char * src;
int index;
{
return (tclStubsPtr->tcl_UtfAtIndex)(src, index);
}
int
Tcl_UtfCharComplete(src, len)
CONST char * src;
int len;
{
return (tclStubsPtr->tcl_UtfCharComplete)(src, len);
}
int
Tcl_UtfBackslash(src, readPtr, dst)
CONST char * src;
int * readPtr;
char * dst;
{
return (tclStubsPtr->tcl_UtfBackslash)(src, readPtr, dst);
}
char *
Tcl_UtfFindFirst(src, ch)
CONST char * src;
int ch;
{
return (tclStubsPtr->tcl_UtfFindFirst)(src, ch);
}
char *
Tcl_UtfFindLast(src, ch)
CONST char * src;
int ch;
{
return (tclStubsPtr->tcl_UtfFindLast)(src, ch);
}
char *
Tcl_UtfNext(src)
CONST char * src;
{
return (tclStubsPtr->tcl_UtfNext)(src);
}
char *
Tcl_UtfPrev(src, start)
CONST char * src;
CONST char * start;
{
return (tclStubsPtr->tcl_UtfPrev)(src, start);
}
int
Tcl_UtfToExternal(interp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr)
Tcl_Interp * interp;
Tcl_Encoding encoding;
CONST char * src;
int srcLen;
int flags;
Tcl_EncodingState * statePtr;
char * dst;
int dstLen;
int * srcReadPtr;
int * dstWrotePtr;
int * dstCharsPtr;
{
return (tclStubsPtr->tcl_UtfToExternal)(interp, encoding, src, srcLen, flags, statePtr, dst, dstLen, srcReadPtr, dstWrotePtr, dstCharsPtr);
}
char *
Tcl_UtfToExternalDString(encoding, src, srcLen, dsPtr)
Tcl_Encoding encoding;
CONST char * src;
int srcLen;
Tcl_DString * dsPtr;
{
return (tclStubsPtr->tcl_UtfToExternalDString)(encoding, src, srcLen, dsPtr);
}
int
Tcl_UtfToLower(src)
char * src;
{
return (tclStubsPtr->tcl_UtfToLower)(src);
}
int
Tcl_UtfToTitle(src)
char * src;
{
return (tclStubsPtr->tcl_UtfToTitle)(src);
}
int
Tcl_UtfToUniChar(src, chPtr)
CONST char * src;
Tcl_UniChar * chPtr;
{
return (tclStubsPtr->tcl_UtfToUniChar)(src, chPtr);
}
int
Tcl_UtfToUpper(src)
char * src;
{
return (tclStubsPtr->tcl_UtfToUpper)(src);
}
int
Tcl_WriteChars(chan, src, srcLen)
Tcl_Channel chan;
CONST char * src;
int srcLen;
{
return (tclStubsPtr->tcl_WriteChars)(chan, src, srcLen);
}
int
Tcl_WriteObj(chan, objPtr)
Tcl_Channel chan;
Tcl_Obj * objPtr;
{
return (tclStubsPtr->tcl_WriteObj)(chan, objPtr);
}
char *
Tcl_GetString(objPtr)
Tcl_Obj * objPtr;
{
return (tclStubsPtr->tcl_GetString)(objPtr);
}
char *
Tcl_GetDefaultEncodingDir()
{
return (tclStubsPtr->tcl_GetDefaultEncodingDir)();
}
void
Tcl_SetDefaultEncodingDir(path)
char * path;
{
(tclStubsPtr->tcl_SetDefaultEncodingDir)(path);
}
void
Tcl_AlertNotifier(clientData)
ClientData clientData;
{
(tclStubsPtr->tcl_AlertNotifier)(clientData);
}
void
Tcl_ServiceModeHook(mode)
int mode;
{
(tclStubsPtr->tcl_ServiceModeHook)(mode);
}