placed within it. For \fBTcl_DictObjFirst\fR and

\fBTcl_DictObjNext\fR, this may be NULL to indicate that the caller is

not interested in the value.

Points to a variable that will have the number of key/value pairs

contained within the dictionary placed within it.

.AP Tcl_DictSearch *searchPtr in/out

to \fBpath\fR type.

.AP Tcl_Obj *listObj in

The list of path elements to operate on with a \fBjoin\fR operation.

.AP Tcl_Obj **errorPtr out

In the case of an error, filled with a value containing the name of

the file which caused an error in the various copy/rename operations.

For \fBTcl_SetListObj\fR,

this points to the Tcl value that will be converted to a list value

containing the \fIobjc\fR elements of the array referenced by \fIobjv\fR.

Points to location where \fBTcl_ListObjGetElements\fR

stores the number of element values in \fIlistPtr\fR.

.AP Tcl_Obj ***objvPtr out

A location where \fBTcl_ListObjGetElements\fR stores a pointer to an array

of pointers to the element values of \fIlistPtr\fR.

The number of Tcl values that \fBTcl_NewListObj\fR

will insert into a new list value,

and \fBTcl_ListObjReplace\fR will insert into \fIlistPtr\fR.

\fBTcl_NewListObj\fR will insert these values into a new list value

and \fBTcl_ListObjReplace\fR will insert them into an existing \fIlistPtr\fR.

Each value will become a separate list element.

Points to location where \fBTcl_ListObjLength\fR

stores the length of the list.

Index of the list element that \fBTcl_ListObjIndex\fR

is to return.

The first element has index 0.

.AP Tcl_Obj **objPtrPtr out

Points to place where \fBTcl_ListObjIndex\fR is to store

a pointer to the resulting list element value.

Index of the starting list element that \fBTcl_ListObjReplace\fR

is to replace.

The list's first element has index 0.

The number of elements that \fBTcl_ListObjReplace\fR

is to replace.

.BE

.PP

\fBTcl_ListObjLength\fR returns the number of elements in the list value

referenced by \fIlistPtr\fR.

If the value is not already a list value,

\fBTcl_ListObjLength\fR will attempt to convert it to one;

if the conversion fails, it returns \fBTCL_ERROR\fR

is left.

.AP "const char" *list in

Pointer to a string with proper list structure.

Filled in with number of elements in \fIlist\fR.

.AP "const char" ***argvPtr out

\fI*argvPtr\fR will be filled in with the address of an array of

pointers to the strings that are the extracted elements of \fIlist\fR.

There will be \fI*argcPtr\fR valid entries in the array, followed by

a NULL entry.

Number of elements in \fIargv\fR.

.AP "const char *const" *argv in

Array of strings to merge together into a single list.

.AP "const char" *path in

File path in a form appropriate for the current platform (see the

\fBfilename\fR manual entry for acceptable forms for path names).

Filled in with number of path elements in \fIpath\fR.

.AP "const char" ***argvPtr out

\fI*argvPtr\fR will be filled in with the address of an array of

pointers to the strings that are the extracted elements of \fIpath\fR.

There will be \fI*argcPtr\fR valid entries in the array, followed by

a NULL entry.

Number of elements in \fIargv\fR.

.AP "const char *const" *argv in

Array of path elements to merge together into a single path.

following code:

.PP

.CS

char *path;

char **argv;

\&...

int line)

}

declare 25 {

const char *file, int line)

}

# Removed in 9.0 (changed to macro):

Tcl_Obj *objPtr)

}

declare 45 {

int *objcPtr, Tcl_Obj ***objvPtr)

}

declare 46 {

Tcl_Obj **objPtrPtr)

}

declare 47 {

int *lengthPtr)

}

declare 48 {

}

# Removed in 9.0 (changed to macro):

#declare 49 {

# Tcl_Obj *Tcl_NewIntObj(int intValue)

#}

declare 53 {

}

# Removed in 9.0 (changed to macro):

#declare 54 {

# void Tcl_SetIntObj(Tcl_Obj *objPtr, int intValue)

#}

declare 62 {

}

# Removed in 9.0 (changed to macro):

#declare 63 {

void Tcl_SourceRCFile(Tcl_Interp *interp)

}

declare 242 {

const char ***argvPtr)

}

# Obsolete, use Tcl_FSSplitPath

declare 243 {

}

# Removed in 9.0 (stub entry only)

#declare 244 {

int Tcl_FSConvertToPathType(Tcl_Interp *interp, Tcl_Obj *pathPtr)

}

declare 460 {

}

declare 461 {

}

declare 462 {

int Tcl_FSEqualPaths(Tcl_Obj *firstPtr, Tcl_Obj *secondPtr)

Tcl_Obj *Tcl_FSGetNormalizedPath(Tcl_Interp *interp, Tcl_Obj *pathPtr)

}

declare 464 {

Tcl_Obj *const objv[])

}

declare 465 {

Tcl_Obj *keyPtr)

}

declare 497 {

}

declare 498 {

int Tcl_DictObjFirst(Tcl_Interp *interp, Tcl_Obj *dictPtr,

}

declare 501 {

int Tcl_DictObjPutKeyList(Tcl_Interp *interp, Tcl_Obj *dictPtr,

}

declare 502 {

int Tcl_DictObjRemoveKeyList(Tcl_Interp *interp, Tcl_Obj *dictPtr,

}

declare 503 {

Tcl_Obj *Tcl_NewDictObj(void)

int Tcl_AsyncMarkFromSignal(Tcl_AsyncHandler async, int sigNumber)

}

# ----- BASELINE -- FOR -- 8.7.0 ----- #

##############################################################################

* table. */

int i;

return TCL_ERROR;

}

if (objc % 2 != 0) {

* itself.

*/

&handlerObjc, &handlerObjv);

newObjc = objc + handlerObjc;

newObjv = (Tcl_Obj **)TclStackAlloc(interp, sizeof(Tcl_Obj *) * newObjc);

if (tokenPtr->type == TCL_TOKEN_EXPAND_WORD) {

int numElements;

&numElements);

if (code == TCL_ERROR) {

/*

int numElements;

Tcl_Obj **elements, *temp = copy[wordIdx];

&elements);

objectsUsed += numElements;

while (numElements--) {

TclNRAddCallback(interp, TEOEx_ListCallback, listPtr, eoFramePtr,

objPtr, NULL);

return TclNREvalObjv(interp, objc, objv, flags, NULL);

}

int objc;

Tcl_Obj **objv;

nsObjPtr = objv[0];

if (result == TCL_OK) {

TclMarkTailcall(interp);

TclNRAddCallback(interp, TclNRReleaseValues, listPtr, NULL, NULL,NULL);

return TclNREvalObjv(interp, objc, objv, 0, NULL);

}



TclMarkTailcall(interp);

TclNRAddCallback(interp, InjectHandlerPostCall, corPtr, listPtr,

INT2PTR(nargs), isProbe);

return TclNREvalObjv(interp, objc, objv, 0, NULL);

}

* The macro evals its args more than once: avoid arg++

*/

&listv) != TCL_OK) {

return TCL_ERROR;

}

listc = 1;

count = 1;

} else {

if (count == BINARY_ALL) {

count = listc;

}

* Unpack the tz data.

*/

return TCL_ERROR;

}

while (!found) {

row = LookupLastTransition(interp, fields->seconds, rowc, rowv);

if ((row == NULL)

&cellv) != TCL_OK

|| TclGetIntFromObj(interp, cellv[1],

&fields->tzOffset) != TCL_OK) {

* Unpack the tz data.

*/

return TCL_ERROR;

}

row = LookupLastTransition(interp, fields->seconds, rowc, rowv);

if (row == NULL ||

TclGetIntFromObj(interp, cellv[1], &fields->tzOffset) != TCL_OK) {

return TCL_ERROR;

}

result = TCL_ERROR;

goto done;

}

&statePtr->varcList[i], &statePtr->varvList[i]);

if (statePtr->varcList[i] < 1) {

Tcl_SetObjResult(interp, Tcl_ObjPrintf(

result = TCL_ERROR;

goto done;

}

&statePtr->argcList[i], &statePtr->argvList[i]);

j = statePtr->argcList[i] / statePtr->varcList[i];

* pointer to its array of element pointers.

*/

&elemPtrs) != TCL_OK) {

return TCL_ERROR;

}

return TCL_ERROR;

}

objc -= 2;

objv += 2;

return TCL_ERROR;

}

if (result != TCL_OK) {

return result;

}

return TCL_ERROR;

}

if (result != TCL_OK) {

return result;

}

return TCL_ERROR;

}

if (result != TCL_OK) {

return result;

}

return TCL_ERROR;

}

if (result != TCL_OK) {

return result;

}

}

listObj = objv[1];

return TCL_ERROR;

}

return TCL_ERROR;

}

if (result != TCL_OK) {

return result;

}

Tcl_WrongNumArgs(interp, 1, objv, "list");

return TCL_ERROR;

}

return TCL_ERROR;

}

*/

i++;

&sortInfo.indexc, &indices) != TCL_OK) {

result = TCL_ERROR;

goto done;

* pointer to its array of element pointers.

*/

if (result != TCL_OK) {

goto done;

}

* 1844789]

*/

break;

case REAL:

result = Tcl_GetDoubleFromObj(interp, patObj, &patDouble);

* 1844789]

*/

break;

}

} else {

sortInfo.resultCode = TCL_ERROR;

goto done;

}

&indexv) != TCL_OK) {

sortInfo.resultCode = TCL_ERROR;

goto done;

if (indexPtr) {

Tcl_Obj **indexv;

switch (sortInfo.indexc) {

case 0:

sortInfo.indexv = NULL;

sortInfo.compareCmdPtr = newCommandPtr;

}

&length, &listObjPtrs);

if (sortInfo.resultCode != TCL_OK || length <= 0) {

goto done;

* Replace them and evaluate the result.

*/

Tcl_ListObjReplace(infoPtr->interp, infoPtr->compareCmdPtr, objc - 2,

2, 2, paramObjv);

&objc, &objv);

infoPtr->resultCode = Tcl_EvalObjv(infoPtr->interp, objc, objv, 0);

int listLen, index;

Tcl_Obj *currentObj;

infoPtr->resultCode = TCL_ERROR;

return NULL;

}

int objc, /* Number of arguments. */

Tcl_Obj *const objv[]) /* Argument objects. */

{

size_t start, end, subStart, subEnd;

Tcl_RegExp regExpr;

Tcl_RegExpInfo info;

if (command) {

Tcl_Obj **args = NULL, **parts;

Tcl_ListObjGetElements(interp, subPtr, &numParts, &parts);

numArgs = numParts + info.nsubs + 1;

chcomp = Tcl_UniCharIsControl;

break;

case STR_IS_DICT: {

dresult = Tcl_DictObjSize(interp, objPtr, &dsize);

Tcl_ResetResult(interp);

* well-formed lists.

*/

break;

}

if (!TclHasStringRep(objv[objc-2])

&& TclHasInternalRep(objv[objc-2], &tclDictType)) {

Tcl_DictSearch search;

/*

}

Tcl_DictObjDone(&search);

} else {

&mapElemv) != TCL_OK) {

return TCL_ERROR;

}

splitObjs = 0;

if (objc == 1) {

Tcl_Obj **listv;

blist = objv[0];

return TCL_ERROR;

}

* Ensure that the list is non-empty.

*/

Tcl_WrongNumArgs(interp, 1, savedObjv,

"?-option ...? string {?pattern body ...? ?default body?}");

return TCL_ERROR;

}

objv = listv;

splitObjs = 1;

}

* The type must be a list of at least length 1.

*/

return TCL_ERROR;

} else if (len < 1) {

Tcl_SetObjResult(interp, Tcl_NewStringObj(

return TCL_ERROR;

}

code = 1;

Tcl_SetObjResult(interp, Tcl_ObjPrintf(

"bad prefix '%s': must be a list",

TclGetString(objv[i+1])));

info[2] = objv[i+1];

commonHandler:

Tcl_DecrRefCount(handlersObj);

return TCL_ERROR;

}

int result)

{

Tcl_Obj *resultObj, *options, *handlersObj, *finallyObj, *cmdObj, **objv;

handlersObj = (Tcl_Obj *)data[0];

finallyObj = (Tcl_Obj *)data[1];

Tcl_ListObjGetElements(NULL, handlersObj, &numHandlers, &handlers);

for (i=0 ; i<numHandlers ; i++) {

Tcl_Obj *handlerBodyObj;

Tcl_ListObjGetElements(NULL, handlers[i], &numElems, &info);

if (!found) {

if (code == TCL_ERROR) {

Tcl_Obj *errorCodeName, *errcode, **bits1, **bits2;

TclNewLiteralStringObj(errorCodeName, "-errorcode");

Tcl_DictObjGet(NULL, options, errorCodeName, &errcode);

TclNewObj(literalObj);

isDataLiteral = TclWordKnownAtCompileTime(dataTokenPtr, literalObj);

isDataValid = (isDataLiteral

isDataEven = (isDataValid && (len & 1) == 0);

/*

int len;

size_t slen;

objPtr = Tcl_ConcatObj(len, objs);

Tcl_DecrRefCount(listObj);

bytes = Tcl_GetStringFromObj(objPtr, &slen);

Tcl_Token *varsTokenPtr, *dictTokenPtr, *bodyTokenPtr;

int keyVarIndex, valueVarIndex, nameChars, loopRange, catchRange;

int infoIndex, jumpDisplacement, bodyTargetOffset, emptyTargetOffset;

int collectVar = -1; /* Index of temp var holding the result

* dict. */

const char **argv;

*/

if (!TclWordKnownAtCompileTime(tokenPtr, varListObj) ||

numVars == 0) {

code = TCL_ERROR;

goto done;

* General syntax: [return ?-option value ...? ?result?]

* An even number of words means an explicit result argument is present.

*/

int numWords = parsePtr->numWords;

int explicitResult = (0 == (numWords % 2));

int numOptionWords = numWords - 1 - explicitResult;

if (!TclWordKnownAtCompileTime(mapTokenPtr, mapObj)) {

Tcl_DecrRefCount(mapObj);

return TclCompileBasic2ArgCmd(interp, parsePtr, cmdPtr, envPtr);

Tcl_DecrRefCount(mapObj);

return TclCompileBasic2ArgCmd(interp, parsePtr, cmdPtr, envPtr);

} else if (len != 2) {

CompileWord(envPtr, msgToken, interp, 2);

codeIsList = codeKnown && (TCL_OK ==

codeIsValid = codeIsList && (len != 0);

if (codeIsValid) {

TclNewObj(tmpObj);

Tcl_IncrRefCount(tmpObj);

if (!TclWordKnownAtCompileTime(tokenPtr, tmpObj)

|| (objc == 0)) {

TclDecrRefCount(tmpObj);

goto failedToCompile;

TclDecrRefCount(tmpObj);

goto failedToCompile;

}

|| (objc > 2)) {

TclDecrRefCount(tmpObj);

goto failedToCompile;

JUMP4( JUMP_FALSE, notCodeJumpSource);

if (matchClauses[i]) {

const char *p;

/*

* Match the errorcode according to try/trap rules.

OP( EQ);

JUMP4( JUMP_FALSE, notCodeJumpSource);

if (matchClauses[i]) {

/*

* Match the errorcode according to try/trap rules.

TclAdvanceLines(&envPtr->line, script,

script + TclParseAllWhiteSpace(script, numBytes));

CompileExprTree(interp, opTree, 0, &litObjv, funcObjv,

parsePtr->tokenPtr, envPtr, optimize);

} else {

QCCD *cdPtr = (QCCD *)clientData;

Tcl_Obj *pkgName = cdPtr->pkg;

Tcl_Obj *pDB, *pkgDict, *val, *listPtr;

static const char *const subcmdStrings[] = {

"get", "list", NULL

};

EXTERN Tcl_Obj * Tcl_DbNewDoubleObj(double doubleValue,

const char *file, int line);

/* 25 */

const char *file, int line);

/* Slot 26 is reserved */

/* 27 */

EXTERN int Tcl_ListObjAppendElement(Tcl_Interp *interp,

Tcl_Obj *listPtr, Tcl_Obj *objPtr);

/* 45 */

Tcl_Obj *listPtr, int *objcPtr,

Tcl_Obj ***objvPtr);

/* 46 */

EXTERN int Tcl_ListObjIndex(Tcl_Interp *interp,

Tcl_Obj **objPtrPtr);

/* 47 */

Tcl_Obj *listPtr, int *lengthPtr);

/* 48 */

EXTERN int Tcl_ListObjReplace(Tcl_Interp *interp,

/* Slot 49 is reserved */

/* 50 */

EXTERN Tcl_Obj * Tcl_NewByteArrayObj(const unsigned char *bytes,

EXTERN Tcl_Obj * Tcl_NewDoubleObj(double doubleValue);

/* Slot 52 is reserved */

/* 53 */

/* Slot 54 is reserved */

/* 55 */

EXTERN Tcl_Obj * Tcl_NewObj(void);

EXTERN void Tcl_SetDoubleObj(Tcl_Obj *objPtr, double doubleValue);

/* Slot 61 is reserved */

/* 62 */

Tcl_Obj *const objv[]);

/* Slot 63 is reserved */

/* 64 */

EXTERN void Tcl_SourceRCFile(Tcl_Interp *interp);

/* 242 */

EXTERN int Tcl_SplitList(Tcl_Interp *interp,

const char ***argvPtr);

/* 243 */

const char ***argvPtr);

/* Slot 244 is reserved */

/* Slot 245 is reserved */

EXTERN int Tcl_FSConvertToPathType(Tcl_Interp *interp,

Tcl_Obj *pathPtr);

/* 460 */

/* 461 */

/* 462 */

EXTERN int Tcl_FSEqualPaths(Tcl_Obj *firstPtr,

Tcl_Obj *secondPtr);

EXTERN Tcl_Obj * Tcl_FSGetNormalizedPath(Tcl_Interp *interp,

Tcl_Obj *pathPtr);

/* 464 */

Tcl_Obj *const objv[]);

/* 465 */

EXTERN void * Tcl_FSGetInternalRep(Tcl_Obj *pathPtr,

EXTERN int Tcl_DictObjRemove(Tcl_Interp *interp,

Tcl_Obj *dictPtr, Tcl_Obj *keyPtr);

/* 497 */

int *sizePtr);

/* 498 */

EXTERN int Tcl_DictObjFirst(Tcl_Interp *interp,

EXTERN void Tcl_DictObjDone(Tcl_DictSearch *searchPtr);

/* 501 */

EXTERN int Tcl_DictObjPutKeyList(Tcl_Interp *interp,

Tcl_Obj *const *keyv, Tcl_Obj *valuePtr);

/* 502 */

EXTERN int Tcl_DictObjRemoveKeyList(Tcl_Interp *interp,

Tcl_Obj *const *keyv);

/* 503 */

EXTERN Tcl_Obj * Tcl_NewDictObj(void);

/* 660 */

EXTERN int Tcl_AsyncMarkFromSignal(Tcl_AsyncHandler async,

int sigNumber);

typedef struct {

const struct TclPlatStubs *tclPlatStubs;

void (*reserved22)(void);

Tcl_Obj * (*tcl_DbNewByteArrayObj) (const unsigned char *bytes, size_t numBytes, const char *file, int line); /* 23 */

Tcl_Obj * (*tcl_DbNewDoubleObj) (double doubleValue, const char *file, int line); /* 24 */

void (*reserved26)(void);

Tcl_Obj * (*tcl_DbNewObj) (const char *file, int line); /* 27 */

Tcl_Obj * (*tcl_DbNewStringObj) (const char *bytes, size_t length, const char *file, int line); /* 28 */

void (*tcl_InvalidateStringRep) (Tcl_Obj *objPtr); /* 42 */

int (*tcl_ListObjAppendList) (Tcl_Interp *interp, Tcl_Obj *listPtr, Tcl_Obj *elemListPtr); /* 43 */

int (*tcl_ListObjAppendElement) (Tcl_Interp *interp, Tcl_Obj *listPtr, Tcl_Obj *objPtr); /* 44 */

void (*reserved49)(void);

Tcl_Obj * (*tcl_NewByteArrayObj) (const unsigned char *bytes, size_t numBytes); /* 50 */

Tcl_Obj * (*tcl_NewDoubleObj) (double doubleValue); /* 51 */

void (*reserved52)(void);

void (*reserved54)(void);

Tcl_Obj * (*tcl_NewObj) (void); /* 55 */

Tcl_Obj * (*tcl_NewStringObj) (const char *bytes, size_t length); /* 56 */

void (*tcl_SetByteArrayObj) (Tcl_Obj *objPtr, const unsigned char *bytes, size_t numBytes); /* 59 */

void (*tcl_SetDoubleObj) (Tcl_Obj *objPtr, double doubleValue); /* 60 */

void (*reserved61)(void);

void (*reserved63)(void);

void (*tcl_SetObjLength) (Tcl_Obj *objPtr, size_t length); /* 64 */

void (*tcl_SetStringObj) (Tcl_Obj *objPtr, const char *bytes, size_t length); /* 65 */

const char * (*tcl_SignalId) (int sig); /* 239 */

const char * (*tcl_SignalMsg) (int sig); /* 240 */

void (*tcl_SourceRCFile) (Tcl_Interp *interp); /* 241 */

void (*reserved244)(void);

void (*reserved245)(void);

void (*reserved246)(void);

Tcl_Obj * (*tcl_FSGetCwd) (Tcl_Interp *interp); /* 457 */

int (*tcl_FSChdir) (Tcl_Obj *pathPtr); /* 458 */

int (*tcl_FSConvertToPathType) (Tcl_Interp *interp, Tcl_Obj *pathPtr); /* 459 */

int (*tcl_FSEqualPaths) (Tcl_Obj *firstPtr, Tcl_Obj *secondPtr); /* 462 */

Tcl_Obj * (*tcl_FSGetNormalizedPath) (Tcl_Interp *interp, Tcl_Obj *pathPtr); /* 463 */

void * (*tcl_FSGetInternalRep) (Tcl_Obj *pathPtr, const Tcl_Filesystem *fsPtr); /* 465 */

Tcl_Obj * (*tcl_FSGetTranslatedPath) (Tcl_Interp *interp, Tcl_Obj *pathPtr); /* 466 */

int (*tcl_FSEvalFile) (Tcl_Interp *interp, Tcl_Obj *fileName); /* 467 */

int (*tcl_DictObjPut) (Tcl_Interp *interp, Tcl_Obj *dictPtr, Tcl_Obj *keyPtr, Tcl_Obj *valuePtr); /* 494 */

int (*tcl_DictObjGet) (Tcl_Interp *interp, Tcl_Obj *dictPtr, Tcl_Obj *keyPtr, Tcl_Obj **valuePtrPtr); /* 495 */

int (*tcl_DictObjRemove) (Tcl_Interp *interp, Tcl_Obj *dictPtr, Tcl_Obj *keyPtr); /* 496 */

int (*tcl_DictObjFirst) (Tcl_Interp *interp, Tcl_Obj *dictPtr, Tcl_DictSearch *searchPtr, Tcl_Obj **keyPtrPtr, Tcl_Obj **valuePtrPtr, int *donePtr); /* 498 */

void (*tcl_DictObjNext) (Tcl_DictSearch *searchPtr, Tcl_Obj **keyPtrPtr, Tcl_Obj **valuePtrPtr, int *donePtr); /* 499 */

void (*tcl_DictObjDone) (Tcl_DictSearch *searchPtr); /* 500 */

Tcl_Obj * (*tcl_NewDictObj) (void); /* 503 */

Tcl_Obj * (*tcl_DbNewDictObj) (const char *file, int line); /* 504 */

void (*tcl_RegisterConfig) (Tcl_Interp *interp, const char *pkgName, const Tcl_Config *configuration, const char *valEncoding); /* 505 */

void (*reserved658)(void);

void (*reserved659)(void);

int (*tcl_AsyncMarkFromSignal) (Tcl_AsyncHandler async, int sigNumber); /* 660 */

} TclStubs;

extern const TclStubs *tclStubsPtr;

(tclStubsPtr->tcl_ListObjAppendList) /* 43 */

#define Tcl_ListObjAppendElement \

(tclStubsPtr->tcl_ListObjAppendElement) /* 44 */

#define Tcl_ListObjIndex \

(tclStubsPtr->tcl_ListObjIndex) /* 46 */

#define Tcl_ListObjReplace \

(tclStubsPtr->tcl_ListObjReplace) /* 48 */

/* Slot 49 is reserved */

(tclStubsPtr->tcl_DictObjGet) /* 495 */

#define Tcl_DictObjRemove \

(tclStubsPtr->tcl_DictObjRemove) /* 496 */

#define Tcl_DictObjFirst \

(tclStubsPtr->tcl_DictObjFirst) /* 498 */

#define Tcl_DictObjNext \

/* Slot 659 is reserved */

#define Tcl_AsyncMarkFromSignal \

(tclStubsPtr->tcl_AsyncMarkFromSignal) /* 660 */

#endif /* defined(USE_TCL_STUBS) */

# define Tcl_UtfToWChar (sizeof(wchar_t) != sizeof(short) \

? (int (*)(const char *, wchar_t *))tclStubsPtr->tcl_UtfToChar16 \

: (int (*)(const char *, wchar_t *))Tcl_UtfToUniChar)

#else

# define Tcl_WCharToUtfDString (sizeof(wchar_t) != sizeof(short) \

? (char *(*)(const wchar_t *, size_t, Tcl_DString *))Tcl_UniCharToUtfDString \

*/

if (TclHasInternalRep(objPtr, &tclListType)) {

Tcl_Obj **objv;

/* Cannot fail, we already know the Tcl_ObjType is "list". */

if (objc & 1) {

goto missingValue;

}

TclTraceDictPath(

Tcl_Interp *interp,

Tcl_Obj *dictPtr,

Tcl_Obj *const keyv[],

int flags)

{

Dict *dict, *newDict;

DictGetInternalRep(dictPtr, dict);

if (dict == NULL) {

Tcl_DictObjSize(

Tcl_Interp *interp,

Tcl_Obj *dictPtr,

{

Dict *dict;

Tcl_DictObjPutKeyList(

Tcl_Interp *interp,

Tcl_Obj *dictPtr,

Tcl_Obj *const keyv[],

Tcl_Obj *valuePtr)

{

if (Tcl_IsShared(dictPtr)) {

Tcl_Panic("%s called with shared object", "Tcl_DictObjPutKeyList");

}

Tcl_Panic("%s called with empty key list", "Tcl_DictObjPutKeyList");

}

Tcl_DictObjRemoveKeyList(

Tcl_Interp *interp,

Tcl_Obj *dictPtr,

Tcl_Obj *const keyv[])

{

Dict *dict;

int objc,

Tcl_Obj *const *objv)

{

if (objc != 2) {

Tcl_WrongNumArgs(interp, 1, objv, "dictionary");

Tcl_Obj *scriptObj, *keyVarObj, *valueVarObj;

Tcl_Obj **varv, *keyObj, *valueObj;

Tcl_DictSearch *searchPtr;

if (objc != 4) {

Tcl_WrongNumArgs(interp, 1, objv,

* Parse arguments.

*/

return TCL_ERROR;

}

if (varc != 2) {

TclStackFree(interp, searchPtr);

return TCL_OK;

}

keyVarObj = varv[0];

valueVarObj = varv[1];

scriptObj = objv[3];

Interp *iPtr = (Interp *) interp;

Tcl_Obj **varv, *keyObj, *valueObj;

DictMapStorage *storagePtr;

if (objc != 4) {

Tcl_WrongNumArgs(interp, 1, objv,

* Parse arguments.

*/

return TCL_ERROR;

}

if (varc != 2) {

return TCL_OK;

}

TclNewObj(storagePtr->accumulatorObj);

storagePtr->keyVarObj = varv[0];

storagePtr->valueVarObj = varv[1];

storagePtr->scriptObj = objv[3];

Tcl_Obj *scriptObj, *keyVarObj, *valueVarObj;

Tcl_Obj **varv, *keyObj = NULL, *valueObj = NULL, *resultObj, *boolObj;

Tcl_DictSearch search;

const char *pattern;

if (objc < 3) {

* copying from the "dict for" implementation has occurred!

*/

return TCL_ERROR;

}

if (varc != 2) {

{

Interp *iPtr = (Interp *) interp;

Tcl_Obj *dictPtr, *objPtr;

if (objc < 5 || !(objc & 1)) {

Tcl_WrongNumArgs(interp, 1, objv,

{

Tcl_Obj *dictPtr, *objPtr, **objv;

Tcl_InterpState state;

Tcl_Obj *varName = (Tcl_Obj *)data[0];

Tcl_Obj *argsObj = (Tcl_Obj *)data[1];

int result)

{

Tcl_Obj **pathv;

Tcl_InterpState state;

Tcl_Obj *varName = (Tcl_Obj *)data[0];

Tcl_Obj *keysPtr = (Tcl_Obj *)data[1];

* the result value from TclDictWithInit. */

{

Tcl_Obj *dictPtr, *leafPtr, *valPtr;

Tcl_Obj **keyv;

/*

* Now process our updates on the leaf dictionary.

*/

for (i=0 ; i<keyc ; i++) {

valPtr = Tcl_ObjGetVar2(interp, keyv[i], NULL, 0);

if (valPtr == NULL) {

* Reset while keeping the list internalrep as much as possible.

*/

Tcl_ListObjReplace(interp, result, 0, len, 0, NULL);

}

Tcl_ListObjAppendElement(NULL, result, TclNewInstNameObj(*pc));

{

int dummy;

return TCL_ERROR;

}

TclSetProcessGlobalValue(&encodingSearchPath, searchPath, NULL);

{

int dummy;

return;

}

TclSetProcessGlobalValue(&libraryPath, path, NULL);

searchPath = Tcl_GetEncodingSearchPath();

Tcl_IncrRefCount(searchPath);

map = Tcl_NewDictObj();

Tcl_IncrRefCount(map);

Tcl_FSMatchInDirectory(NULL, matchFileList, directory, "*.enc",

&readableFiles);

for (j=0; j<numFiles; j++) {

Tcl_Obj *encodingName, *fileObj;

Tcl_Channel chan = NULL;

int i, numDirs;

Tcl_IncrRefCount(nameObj);

Tcl_AppendToObj(fileNameObj, ".enc", -1);

Tcl_IncrRefCount(fileNameObj);

Tcl_DStringInit(&escapeData);

while (1) {

const char **argv;

char *line;

Tcl_DString lineString;

Tcl_IncrRefCount(searchPathObj);

libPathObj = TclGetLibraryPath();

Tcl_IncrRefCount(libPathObj);

for (i = 0; i < numDirs; i++) {

Tcl_Obj *directoryObj, *pathObj;

cxtPtr = nsPtr;

continue;

case CRT_SUBCMDS:

if (allocatedMapFlag) {

Tcl_DecrRefCount(mapObj);

}

subcmdObj = (len > 0 ? objv[1] : NULL);

continue;

case CRT_PARAM:

if (allocatedMapFlag) {

Tcl_DecrRefCount(mapObj);

}

Tcl_Obj **listv;

const char *cmd;

&listv) != TCL_OK) {

Tcl_DictObjDone(&search);

if (patchedDict) {

}

continue;

case CRT_UNKNOWN:

if (allocatedMapFlag) {

Tcl_DecrRefCount(mapObj);

}

}

switch ((enum EnsConfigOpts) index) {

case CONF_SUBCMDS:

goto freeMapAndError;

}

subcmdObj = (len > 0 ? objv[1] : NULL);

continue;

case CONF_PARAM:

goto freeMapAndError;

}

paramObj = (len > 0 ? objv[1] : NULL);

continue;

}

do {

&listv) != TCL_OK) {

Tcl_DictObjDone(&search);

if (patchedDict) {

}

continue;

case CONF_UNKNOWN:

goto freeMapAndError;

}

unknownObj = (len > 0 ? objv[1] : NULL);

if (subcmdList != NULL) {

int length;

return TCL_ERROR;

}

if (length < 1) {

if (paramList == NULL) {

length = 0;

} else {

return TCL_ERROR;

}

if (length < 1) {

return TCL_ERROR;

}

if (mapDict != NULL) {

Tcl_DictSearch search;

Tcl_Obj *valuePtr;

if (unknownList != NULL) {

int length;

return TCL_ERROR;

}

if (length < 1) {

Tcl_DString buf, hiddenBuf;

const char **nameParts = NULL;

const char *cmdName = NULL;

/*

* Construct the path for the ensemble namespace and create it.

Tcl_Obj **copyObjv;

int copyObjc, prefixObjc;

if (objc == 2) {

copyPtr = TclListObjCopy(NULL, prefixObj);

*/

TclSkipTailcall(interp);

((Interp *)interp)->lookupNsPtr = ensemblePtr->nsPtr;

return TclNREvalObjv(interp, copyObjc, copyObjv, TCL_EVAL_INVOKE, NULL);

}

for (i=1 ; i<objc ; i++) {

Tcl_ListObjAppendElement(NULL, unknownCmd, objv[i]);

}

Tcl_IncrRefCount(unknownCmd);

/*

/* A non-empty list is the replacement command. */

TclDecrRefCount(*prefixObjPtr);

Tcl_AddErrorInfo(interp, "\n while parsing result of "

"ensemble unknown subcommand handler");

* Determine the target for each.

*/

if (subList == mapDict) {

/*

* Unusual case where explicit list of subcommands is same value

const char *str;

Tcl_Obj *matchObj = NULL;

goto failed;

}

for (i=0 ; i<len ; i++) {

doneMapLookup:

Tcl_ListObjAppendElement(NULL, replaced, replacement);

goto failed;

} else if (len != 1) {

/*

Tcl_Token *tokPtr;

Tcl_Obj *objPtr, **words;

const char *bytes;

/*

* Push the words of the command. Take care; the command words may be

Tcl_ListObjGetElements(NULL, replacements, &numWords, &words);

for (i = 0, tokPtr = parsePtr->tokenPtr; i < parsePtr->numWords;

i++, tokPtr = TokenAfter(tokPtr)) {

bytes = Tcl_GetStringFromObj(words[i-1], &length);

PushLiteral(envPtr, bytes, length);

continue;

errPtr = assocPtr->firstBgPtr;

tempObjv = (Tcl_Obj**)Tcl_Alloc((prefixObjc+2) * sizeof(Tcl_Obj *));

memcpy(tempObjv, prefixObjv, prefixObjc*sizeof(Tcl_Obj *));

tempObjv[prefixObjc] = errPtr->errorMsg;

Tcl_Obj *objPtr, *valuePtr, *value2Ptr, *part1Ptr, *part2Ptr, *tmpPtr;

Tcl_Obj **objv = NULL;

int objc = 0;

Var *varPtr, *arrayPtr;

#ifdef TCL_COMPILE_DEBUG

char cmdNameBuf[21];

objPtr = OBJ_AT_TOS;

TRACE(("\"%.30s\" => ", O2S(objPtr)));

TRACE_ERROR(interp);

goto gotError;

}

TclMarkTailcall(interp);

TclNRAddCallback(interp, TclClearRootEnsemble, NULL, NULL, NULL, NULL);

TclNRAddCallback(interp, TclNRReleaseValues, objPtr, NULL, NULL, NULL);

return TclNREvalObjv(interp, objc, objv, TCL_EVAL_INVOKE, NULL);

varPtr = varPtr->value.linkPtr;

}

TRACE(("%u <- \"%.30s\" => ", opnd, O2S(valuePtr)));

!= TCL_OK) {

TRACE_ERROR(interp);

goto gotError;

}

TRACE(("%u \"%.30s\" \"%.30s\" => ",

opnd, O2S(part2Ptr), O2S(valuePtr)));

!= TCL_OK) {

TRACE_ERROR(interp);

goto gotError;

lappendListDirect:

objResultPtr = varPtr->value.objPtr;

TRACE_ERROR(interp);

goto gotError;

}

lappendList:

opnd = -1;

!= TCL_OK) {

TRACE_ERROR(interp);

goto gotError;

if (!objResultPtr) {

valueToAssign = valuePtr;

TRACE_ERROR(interp);

goto gotError;

} else {

case INST_LIST_LENGTH:

TRACE(("\"%.30s\" => ", O2S(OBJ_AT_TOS)));

TRACE_ERROR(interp);

goto gotError;

}

* Extract the desired list element.

*/

&& !TclHasInternalRep(value2Ptr, &tclListType)) {

int code;

* in the process.

*/

TRACE_ERROR(interp);

goto gotError;

}

* in the process.

*/

TRACE_ERROR(interp);

goto gotError;

}

s1 = Tcl_GetStringFromObj(valuePtr, &s1len);

TRACE(("\"%.30s\" \"%.30s\" => ", O2S(valuePtr), O2S(value2Ptr)));

TRACE_ERROR(interp);

goto gotError;

}

match = 0;

if (length > 0) {

Tcl_Obj *o;

/*

varListPtr = infoPtr->varLists[i];

numVars = varListPtr->numVars;

listPtr = OBJ_AT_DEPTH(listTmpDepth);

TRACE_APPEND(("ERROR converting list %ld, \"%s\": %s",

i, O2S(listPtr), O2S(Tcl_GetObjResult(interp))));

goto gotError;

numVars = varListPtr->numVars;

listPtr = OBJ_AT_DEPTH(listTmpDepth);

valIndex = (iterNum * numVars);

for (j = 0; j < numVars; j++) {

*/

{

Tcl_Obj *dictPtr, *statePtr, *keyPtr, *listPtr, *varNamePtr, *keysPtr;

Tcl_Obj *emptyPtr, **keyPtrPtr;

Tcl_DictSearch *searchPtr;

DictUpdateInfo *duiPtr;

dictPtr = OBJ_AT_TOS;

TRACE(("\"%.30s\" => ", O2S(dictPtr)));

TRACE_APPEND(("ERROR verifying dictionary nature of \"%.30s\": %s\n",

O2S(dictPtr), O2S(Tcl_GetObjResult(interp))));

goto gotError;

}

TRACE_APPEND(("OK\n"));

NEXT_INST_F(1, 1, 0);

break;

case INST_DICT_EXISTS: {

}

}

Tcl_IncrRefCount(dictPtr);

&keyPtrPtr) != TCL_OK) {

TRACE_ERROR(interp);

goto gotError;

}

Tcl_Panic("dictUpdateStart argument length mismatch");

}

for (i=0 ; i<length ; i++) {

NEXT_INST_F(9, 1, 0);

}

if (Tcl_DictObjSize(interp, dictPtr, &length) != TCL_OK

&keyPtrPtr) != TCL_OK) {

TRACE_ERROR(interp);

goto gotError;

dictPtr = OBJ_UNDER_TOS;

listPtr = OBJ_AT_TOS;

TRACE(("\"%.30s\" \"%.30s\" =>", O2S(dictPtr), O2S(listPtr)));

TRACE_ERROR(interp);

goto gotError;

}

listPtr = OBJ_AT_TOS;

TRACE(("\"%.30s\" \"%.30s\" \"%.30s\" => ",

O2S(varNamePtr), O2S(valuePtr), O2S(keysPtr)));

TRACE_ERROR(interp);

TclDecrRefCount(keysPtr);

goto gotError;

varPtr = LOCAL(opnd);

TRACE(("%u <- \"%.30s\" \"%.30s\" => ", opnd, O2S(valuePtr),

O2S(keysPtr)));

TRACE_ERROR(interp);

goto gotError;

}

Tcl_Obj *const objv[]) /* Argument strings passed to Tcl_FileCmd. */

{

Tcl_Obj *errfile = NULL;

Tcl_Obj *split = NULL;

Tcl_Obj *target = NULL;

Tcl_StatBuf statBuf;

Tcl_Interp *interp, /* Interp, for error return. */

Tcl_Obj *pathPtr) /* Path whose basename to extract. */

{

Tcl_Obj *splitPtr;

Tcl_Obj *resultPtr = NULL;

const char *const *attributeStrings;

const char **attributeStringsAllocated = NULL;

Tcl_Obj *objStrings = NULL;

Tcl_Obj *filePtr;

if (objc < 2) {

attributeStrings = Tcl_FSFileAttrStrings(filePtr, &objStrings);

if (attributeStrings == NULL) {

Tcl_Obj *objPtr;

if (objStrings == NULL) {

Tcl_PathType

TclpGetNativePathType(

Tcl_Obj *pathPtr, /* Native path of interest */

* path was absolute */

Tcl_Obj **driveNameRef)

{

Tcl_Obj *

TclpNativeSplitPath(

Tcl_Obj *pathPtr, /* Path to split. */

{

Tcl_Obj *resultPtr = NULL; /* Needed only to prevent gcc warnings. */

void

Tcl_SplitPath(

const char *path, /* Pointer to string containing a path. */

* number of elements in the path. */

const char ***argvPtr) /* Pointer to place to store pointer to array

* of pointers to path elements. */

{

Tcl_Obj *resultPtr = NULL; /* Needed only to prevent gcc warnings. */

Tcl_Obj *tmpPtr, *eltPtr;

char *p;

const char *str;

Tcl_Obj *

Tcl_FSJoinToPath(

Tcl_Obj *pathPtr, /* Valid path or NULL. */

Tcl_Obj *const objv[]) /* Path elements to join. */

{

if (pathPtr == NULL) {

pair[1] = objv[0];

return TclJoinPath(2, pair, 0);

} else {

Tcl_Obj *ret, **elemv = (Tcl_Obj**)Tcl_Alloc(elemc*sizeof(Tcl_Obj *));

elemv[0] = pathPtr;

return TCL_ERROR;

}

typePtr = objv[i+1];

return TCL_ERROR;

}

i++;

* platform.

*/

if (length <= 0) {

goto skipTypes;

}

Tcl_Obj *item;

int llen;

&& (llen == 3)) {

Tcl_ListObjIndex(interp, look, 0, &item);

if (!strcmp("macintosh", TclGetString(item))) {

}

if ((globFlags & TCL_GLOBMODE_NO_COMPLAIN) == 0) {

&length) != TCL_OK) {

/*

* This should never happen. Maybe we should be more dramatic.

Tcl_IncrRefCount(pathPrefix);

} else if (pathPrefix == NULL && (tail[0] == '/'

|| (tail[0] == '\\' && tail[1] == '\\'))) {

Tcl_Obj *driveName;

Tcl_Obj *temp = Tcl_NewStringObj(tail, -1);

Tcl_IncrRefCount(temp);

*/

if (pathPrefix == NULL) {

Tcl_Obj *driveName;

&driveNameLen, &driveName) == TCL_PATH_ABSOLUTE) {

pathPrefix = driveName;

tail += driveNameLen;

}

}

for (i = 0; i< objc; i++) {

size_t len;

const char *oldStr = Tcl_GetStringFromObj(objv[i], &len);

int subdirc, i, repair = -1;

Tcl_Obj **subdirv;

&subdirc, &subdirv);

for (i=0; result==TCL_OK && i<subdirc; i++) {

Tcl_Obj *copy = NULL;

if (pathPtr == NULL && TclGetString(subdirv[i])[0] == '~') {

copy = subdirv[i];

subdirv[i] = Tcl_NewStringObj("./", 2);

Tcl_AppendObjToObj(subdirv[i], copy);

Tcl_DecrRefCount(subdirv[i]);

subdirv[i] = copy;

while (repair < end) {

const char *bytes;

size_t numBytes;

MODULE_SCOPE Tcl_PathType TclFSGetPathType(Tcl_Obj *pathPtr,

const Tcl_Filesystem **filesystemPtrPtr,

MODULE_SCOPE Tcl_PathType TclFSNonnativePathType(const char *pathPtr,

MODULE_SCOPE Tcl_PathType TclGetPathType(Tcl_Obj *pathPtr,

const Tcl_Filesystem **filesystemPtrPtr,

MODULE_SCOPE int TclFSEpochOk(size_t filesystemEpoch);

MODULE_SCOPE int TclFSCwdIsNative(void);

MODULE_SCOPE Tcl_Obj * TclWinVolumeRelativeNormalize(Tcl_Interp *interp,

const char *genericopt =

"blocking buffering buffersize encoding eofchar translation";

const char **argv;

Tcl_DString ds;

Tcl_Obj *errObj;

ChannelState *statePtr = chanPtr->state;

/* State info for channel */

size_t len; /* Length of optionName string. */

const char **argv;

/*

* information. Hence an error means that we've got serious breakage.

*/

if (res != TCL_OK) {

Tcl_Panic("Tcl_SetChannelError: bad syntax of message");

}

if (!pipeline) {

chan = Tcl_FSOpenFileChannel(interp, objv[1], modeString, prot);

} else {

const char **cmdArgv;

if (Tcl_SplitList(interp, what+1, &cmdObjc, &cmdArgv) != TCL_OK) {

Channel *chanPtr; /* The actual channel. */

ChannelState *statePtr; /* State info for channel. */

int mode; /* Read/write mode of the channel. */

TransformChannelData *dataPtr;

Tcl_DString ds;

* Compare open mode against optional r/w.

*/

Tcl_SetObjResult(interp, Tcl_ObjPrintf(

"chan handler \"%s initialize\" returned non-list: %s",

TclGetString(cmdObj), TclGetString(resObj)));

* information; if we panic here, something has gone badly wrong already.

*/

Tcl_Panic("TclChanCaughtErrorBypass: Bad syntax of caught result");

}

if (interp == NULL) {

* result is a valid list. Nor that the list has an even number elements.

*/

goto error;

}

int evIndex; /* Id of event for an element of the eventspec

* list. */

return TCL_ERROR;

}

int listc;

Tcl_Obj **listv;

&listv) != TCL_OK) {

Tcl_DecrRefCount(resObj);

resObj = MarshallError(interp);

* through the mask. Compare open mode against optional r/w.

*/

Tcl_SetObjResult(interp, Tcl_ObjPrintf(

"chan handler \"%s initialize\" returned non-list: %s",

TclGetString(cmdObj), TclGetString(resObj)));

* information; if we panic here, something has gone badly wrong already.

*/

Tcl_Panic("TclChanCaughtErrorBypass: Bad syntax of caught result");

}

if (interp == NULL) {

/* ASSERT: cmdpfxObj is a Tcl List */

/*

* See [==] as well.

* resultPtr and tmpResultPtr are guaranteed to be distinct.

*/

&resLength, &elemsPtr);

for (i=0 ; ret==TCL_OK && i<resLength ; i++) {

ret = Tcl_ListObjAppendElement(interp, resultPtr,

* directory flag is particularly significant.

*/

{

int dir = (types == NULL || (types->type & TCL_GLOB_TYPE_DIR));

Tcl_Obj *mounts = FsListMounts(pathPtr, pattern);

}

for (i=0 ; i<mLength ; i++) {

Tcl_Obj *mElt;

int found = 0;

Tcl_ListObjIndex(NULL, mounts, i, &mElt);

* configure the channel for binary

* operations after opening the file. */

{

const char **modeArgv, *flag;

#define RW_MODES (O_RDONLY|O_WRONLY|O_RDWR)

int i, objc;

Tcl_Obj **objv;

TclDecrRefCount(listObj);

return TCL_ERROR;

}

Tcl_Obj *

Tcl_FSSplitPath(

Tcl_Obj *pathPtr, /* The pathname to split. */

* elements. */

{

Tcl_Obj *result = NULL; /* Just to squelch gcc warnings. */

const Tcl_Filesystem *fsPtr;

char separator = '/';

const char *p;

/*

for (;;) {

const char *elementStart = p;

while ((*p != '\0') && (*p != separator)) {

p++;

}

if (lenPtr != NULL) {

}

return result;

}

/* If not NULL, a place in which to store a

* pointer to the filesystem for this pathname

* if it is absolute. */

* length of the volume name. */

Tcl_Obj **driveNameRef) /* If not NULL, for an absolute pathname, a

* place to store a pointer to an object with a

Tcl_PathType

TclFSNonnativePathType(

const char *path, /* Pathname to determine the type of. */

const Tcl_Filesystem **filesystemPtrPtr,

/* If not NULL, a place to store a pointer to

* the filesystem for this pathname when it is

* an absolute pathname. */

* the volume name if the pathname is absolute.

*/

Tcl_Obj **driveNameRef) /* If not NULL, a place to store a pointer to

if ((fsRecPtr->fsPtr != &tclNativeFilesystem)

&& (fsRecPtr->fsPtr->listVolumesProc != NULL)) {

Tcl_Obj *thisFsVolumes = fsRecPtr->fsPtr->listVolumesProc();

if (thisFsVolumes != NULL) {

* Tcl_Panic seems a bit excessive.

*/

}

Tcl_Obj *vol;

size_t len;

const char *strVol;

numVolumes--;

Tcl_ListObjIndex(NULL, thisFsVolumes, numVolumes, &vol);

strVol = Tcl_GetStringFromObj(vol,&len);

continue;

}

if (strncmp(strVol, path, len) == 0) {

* of the code there. This is a bit ineffiecient but simpler.

*/

if (result != TCL_OK) {

return result;

}

int objc, /* Number of arguments. */

Tcl_Obj *const objv[]) /* Argument objects. */

{

Tcl_Obj *errorPtr = NULL;

const char *message = "option";

Tcl_Obj *tablePtr, *objPtr, *resultPtr;

return TCL_ERROR;

}

if (result != TCL_OK) {

return result;

}

return TCL_ERROR;

}

if (result != TCL_OK) {

return result;

}

}

declare 225 {

Tcl_Obj *TclTraceDictPath(Tcl_Interp *interp, Tcl_Obj *rootPtr,

}

declare 226 {

int TclObjBeingDeleted(Tcl_Obj *objPtr)

typedef struct List {

size_t refCount;

int canonicalFlag; /* Set if the string representation was

* derived from the list representation. May

* be ignored if there is no string rep at

MODULE_SCOPE int TclInterpReady(Tcl_Interp *interp);

MODULE_SCOPE int TclIsDigitProc(int byte);

MODULE_SCOPE int TclIsBareword(int byte);

int forceRelative);

MODULE_SCOPE int TclJoinThread(Tcl_ThreadId id, int *result);

MODULE_SCOPE void TclLimitRemoveAllHandlers(Tcl_Interp *interp);

MODULE_SCOPE Tcl_Obj * TclLindexList(Tcl_Interp *interp,

Tcl_Obj *listPtr, Tcl_Obj *argPtr);

MODULE_SCOPE Tcl_Obj * TclLindexFlat(Tcl_Interp *interp, Tcl_Obj *listPtr,

/* TIP #280 */

MODULE_SCOPE void TclListLines(Tcl_Obj *listObj, int line, int n,

int *lines, Tcl_Obj *const *elems);

MODULE_SCOPE int TclpObjNormalizePath(Tcl_Interp *interp,

Tcl_Obj *pathPtr, int nextCheckpoint);

MODULE_SCOPE void TclpNativeJoinPath(Tcl_Obj *prefix, const char *joining);

MODULE_SCOPE Tcl_PathType TclpGetNativePathType(Tcl_Obj *pathPtr,

MODULE_SCOPE int TclCrossFilesystemCopy(Tcl_Interp *interp,

Tcl_Obj *source, Tcl_Obj *target);

MODULE_SCOPE int TclpMatchInDirectory(Tcl_Interp *interp,

EXTERN TclPlatformType * TclGetPlatform(void);

/* 225 */

EXTERN Tcl_Obj * TclTraceDictPath(Tcl_Interp *interp,

Tcl_Obj *const keyv[], int flags);

/* 226 */

EXTERN int TclObjBeingDeleted(Tcl_Obj *objPtr);

void (*reserved222)(void);

void (*reserved223)(void);

TclPlatformType * (*tclGetPlatform) (void); /* 224 */

int (*tclObjBeingDeleted) (Tcl_Obj *objPtr); /* 226 */

void (*tclSetNsPath) (Namespace *nsPtr, size_t pathLength, Tcl_Namespace *pathAry[]); /* 227 */

void (*reserved228)(void);

Tcl_Interp *searchInterp; /* Interim storage for interp. to find. */

InterpInfo *parentInfoPtr;

return NULL;

}

Tcl_Obj *const objv[]) /* Argument strings. */

{

if (objc) {

|| (length < 1)) {

Tcl_SetObjResult(interp, Tcl_NewStringObj(

"cmdPrefix must be list of length >= 1", -1));

int isNew, objc;

Tcl_Obj **objv;

return NULL;

}

if (objc < 2) {

*/

if (linkPtr->flags & LINK_ALLOC_LAST) {

|| (size_t)objc != linkPtr->numElems) {

return (char *) "wrong dimension";

}

* Prototypes for functions defined later in this file:

*/

Tcl_Obj *const objv[]);

static void DupListInternalRep(Tcl_Obj *srcPtr, Tcl_Obj *copyPtr);

static void FreeListInternalRep(Tcl_Obj *listPtr);

static int SetListFromAny(Tcl_Interp *interp, Tcl_Obj *objPtr);

static List *

NewListIntRep(

Tcl_Obj *const objv[],

{

List *listRepPtr;

listRepPtr = (List *)Tcl_AttemptAlloc(LIST_SIZE(objc));

if (listRepPtr == NULL) {

if (p) {

if (objv) {

Tcl_Obj **elemPtrs;

listRepPtr->elemCount = objc;

elemPtrs = &listRepPtr->elements;

static List *

AttemptNewList(

Tcl_Interp *interp,

Tcl_Obj *const objv[])

{

List *listRepPtr = NewListIntRep(objc, objv, 0);

Tcl_Obj *

Tcl_NewListObj(

Tcl_Obj *const objv[]) /* An array of pointers to Tcl objects. */

{

return Tcl_DbNewListObj(objc, objv, "unknown", 0);

Tcl_Obj *

Tcl_NewListObj(

Tcl_Obj *const objv[]) /* An array of pointers to Tcl objects. */

{

List *listRepPtr;

TclNewObj(listPtr);

return listPtr;

}

Tcl_Obj *

Tcl_DbNewListObj(

Tcl_Obj *const objv[], /* An array of pointers to Tcl objects. */

const char *file, /* The name of the source file calling this

* function; used for debugging. */

TclDbNewObj(listPtr, file, line);

return listPtr;

}

Tcl_Obj *

Tcl_DbNewListObj(

Tcl_Obj *const objv[], /* An array of pointers to Tcl objects. */

TCL_UNUSED(const char *) /*file*/,

TCL_UNUSED(int) /*line*/)

void

Tcl_SetListObj(

Tcl_Obj *objPtr, /* Object whose internal rep to init. */

Tcl_Obj *const objv[]) /* An array of pointers to Tcl objects. */

{

List *listRepPtr;

size_t toIdx) /* Index of last element to include. */

{

Tcl_Obj **elemPtrs;

size_t i, newLen;

List *listRepPtr;

if (fromIdx == TCL_INDEX_NONE) {

fromIdx = 0;

}

toIdx = listLen-1;

}

if (fromIdx + 1 > toIdx + 1) {

Tcl_Interp *interp, /* Used to report errors if not NULL. */

Tcl_Obj *listPtr, /* List object for which an element array is

* to be returned. */

* referenced by objv. */

Tcl_Obj ***objvPtr) /* Where to store the pointer to an array of

* pointers to the list's objects. */

Tcl_Obj *listPtr, /* List object to append elements to. */

Tcl_Obj *elemListPtr) /* List obj with elements to append. */

{

Tcl_Obj **objv;

if (Tcl_IsShared(listPtr)) {

* Pull the elements to append from elemListPtr.

*/

return TCL_ERROR;

}

Tcl_Obj *objPtr) /* Object to append to listPtr's list. */

{

List *listRepPtr, *newPtr = NULL;

if (Tcl_IsShared(listPtr)) {

Tcl_Panic("%s called with shared object", "Tcl_ListObjAppendElement");

Tcl_ListObjIndex(

Tcl_Interp *interp, /* Used to report errors if not NULL. */

Tcl_Obj *listPtr, /* List object to index into. */

Tcl_Obj **objPtrPtr) /* The resulting Tcl_Obj* is stored here. */

{

List *listRepPtr;

ListGetIntRep(listPtr, listRepPtr);

}

*objPtrPtr = NULL;

} else {

*objPtrPtr = (&listRepPtr->elements)[index];

Tcl_ListObjLength(

Tcl_Interp *interp, /* Used to report errors if not NULL. */

Tcl_Obj *listPtr, /* List object whose #elements to return. */

{

List *listRepPtr;

Tcl_ListObjReplace(

Tcl_Interp *interp, /* Used for error reporting if not NULL. */

Tcl_Obj *listPtr, /* List object whose elements to replace. */

Tcl_Obj *const objv[]) /* An array of objc pointers to Tcl objects to

* insert. */

{

List *listRepPtr;

Tcl_Obj **elemPtrs;

if (Tcl_IsShared(listPtr)) {

Tcl_Panic("%s called with shared object", "Tcl_ListObjReplace");

elemPtrs = &listRepPtr->elements;

numElems = listRepPtr->elemCount;

first = 0;

}

if (first >= numElems) {

first = numElems; /* So we'll insert after last element. */

}

count = 0;

} else if (first > INT_MAX - count /* Handle integer overflow */

|| numElems < first+count) {

count = numElems - first;

}

isShared = (listRepPtr->refCount > 1);

numRequired = numElems - count + objc; /* Known <= LIST_MAX */

needGrow = numRequired > listRepPtr->maxElemCount;

if (needGrow && !isShared) {

/* Try to use realloc */

List *newPtr = NULL;

if (attempt <= LIST_MAX) {

newPtr = (List *)Tcl_AttemptRealloc(listRepPtr, LIST_SIZE(attempt));

}

TclLindexFlat(

Tcl_Interp *interp, /* Tcl interpreter. */

Tcl_Obj *listPtr, /* Tcl object representing the list. */

Tcl_Obj *const indexArray[])/* Array of pointers to Tcl objects that

* represent the indices in the list. */

{

Tcl_IncrRefCount(listPtr);

for (i=0 ; i<indexCount && listPtr ; i++) {

size_t index;

Tcl_Obj **elemPtrs = NULL, *sublistCopy;

/*

break;

}

if (TclGetIntForIndexM(interp, indexArray[i], /*endValue*/ listLen-1,

&index) == TCL_OK) {

Tcl_Obj *indexArgPtr, /* Index or index-list arg to 'lset'. */

Tcl_Obj *valuePtr) /* Value arg to 'lset' or NULL to 'lpop'. */

{

Tcl_Obj **indices = NULL; /* Vector of indices in the index list. */

Tcl_Obj *retValuePtr; /* Pointer to the list to be returned. */

size_t index; /* Current index in the list - discarded. */

return TclLsetFlat(interp, listPtr, 1, &indexArgPtr, valuePtr);

}

/*

* Let TclLsetFlat handle the actual lset'ting.

/* Index args. */

Tcl_Obj *valuePtr) /* Value arg to 'lset' or NULL to 'lpop'. */

{

Tcl_Obj *subListPtr, *retValuePtr, *chainPtr;

Tcl_ObjInternalRep *irPtr;

*/

do {

Tcl_Obj *parentList, **elemPtrs;

/*

* Check for the possible error conditions...

*/

!= TCL_OK) {

/* ...the sublist we're indexing into isn't a list at all. */

result = TCL_ERROR;

}

/*

*/

if (valuePtr == NULL) {

Tcl_ListObjReplace(NULL, subListPtr, index, 1, 0, NULL);

} else if (index == (size_t)len) {

if (!TclHasStringRep(objPtr) && TclHasInternalRep(objPtr, &tclDictType)) {

Tcl_Obj *keyPtr, *valuePtr;

Tcl_DictSearch search;

/*

* Create the new list representation. Note that we do not need to do

Tcl_DStringAppend(&pfx, prefix, -1);

} else {

Tcl_Obj *splitPtr, *pkgGuessPtr;

const char *pkgGuess;

/*

* There is a path given, so parse it into an array of namespace pointers.

*/

goto badNamespace;

}

if (nsObjc != 0) {

*/

if (handlerPtr != NULL) {

/*

* Not a list.

*/

int len;

iPtr->resetErrorStack = 0;

/*

* Reset while keeping the list internalrep as much as possible.

int len;

iPtr->resetErrorStack = 0;

/*

* Reset while keeping the list internalrep as much as possible.

Tcl_ListObjAppendElement(NULL, objPtr, obj2Ptr);

/* TODO: overflow? */

Tcl_ListObjReplace(NULL, objPtr, 1, 0, objc - offset, objv + offset);

result = Tcl_EvalObjv(interp, objc - cmdIndex, objs, TCL_EVAL_INVOKE);

if (isRoot) {

"attempt to misuse API", -1));

Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);

return TCL_ERROR;

&filterv) != TCL_OK) {

return TCL_ERROR;

}

"attempt to misuse API", -1));

Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);

return TCL_ERROR;

&mixinv) != TCL_OK) {

return TCL_ERROR;

}

"may not modify the superclass of the root object", -1));

Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);

return TCL_ERROR;

&superv) != TCL_OK) {

return TCL_ERROR;

}

"attempt to misuse API", -1));

Tcl_SetErrorCode(interp, "TCL", "OO", "MONKEY_BUSINESS", NULL);

return TCL_ERROR;

&varv) != TCL_OK) {

return TCL_ERROR;

}

return TCL_ERROR;

}

objv += Tcl_ObjectContextSkippedArgs(context);

&filterv) != TCL_OK) {

return TCL_ERROR;

}

return TCL_ERROR;

}

objv += Tcl_ObjectContextSkippedArgs(context);

&mixinv) != TCL_OK) {

return TCL_ERROR;

}

return TCL_ERROR;

}

objv += Tcl_ObjectContextSkippedArgs(context);

&varv) != TCL_OK) {

return TCL_ERROR;

}

* structure's contents. NULL if caller is not

* interested. */

{

ProcedureMethod *pmPtr;

Tcl_Method method;

TclNewObj(argsObj);

Tcl_IncrRefCount(argsObj);

procName = "<destructor>";

return NULL;

} else {

procName = (nameObj==NULL ? "<constructor>" : TclGetString(nameObj));

int prefixLen;

ForwardMethod *fmPtr;

return NULL;

}

if (prefixLen < 1) {

int prefixLen;

ForwardMethod *fmPtr;

return NULL;

}

if (prefixLen < 1) {

* can ignore here.

*/

argObjs = InitEnsembleRewrite(interp, objc, objv, skip,

numPrefixes, prefixObjs, &len);

Tcl_NRAddCallback(interp, FinalizeForwardCall, argObjs, NULL, NULL, NULL);

{

Tcl_HashEntry *hPtr;

Tcl_HashSearch search;

/*

* Get the test for a valid list out of the way first.

*/

return TCL_ERROR;

}

TclFSGetPathType(

Tcl_Obj *pathPtr,

const Tcl_Filesystem **filesystemPtrPtr,

{

FsPath *fsPathPtr;

goto standardPath;

}

} else {

Tcl_Obj *splitPtr, *resultPtr;

standardPath:

Tcl_FSJoinPath(

Tcl_Obj *listObj, /* Path elements to join, may have a zero

* reference count. */

{

Tcl_Obj *res;

Tcl_Obj **objv;

if (Tcl_ListObjLength(NULL, listObj, &objc) != TCL_OK) {

return NULL;

}

Tcl_ListObjGetElements(NULL, listObj, &objc, &objv);

res = TclJoinPath(elements, objv, 0);

return res;

Tcl_Obj *

TclJoinPath(

Tcl_Obj * const objv[], /* Path elements to join */

int forceRelative) /* If non-zero, assume all more paths are

* relative (e. g. simple normalization) */

{

Tcl_Obj *res = NULL;

const Tcl_Filesystem *fsPtr = NULL;

assert ( elements >= 0 );

assert ( res == NULL );

for (i = 0; i < elements; i++) {

size_t strEltLen, length;

Tcl_PathType type;

char *strElt, *ptr;

Tcl_Obj **objv;

Tcl_Obj *parts = TclpNativeSplitPath(pathPtr, NULL);

/*

* Skip '~'. It's replaced by its expansion.

objvListPtr = Tcl_NewListObj(0, NULL);

Tcl_IncrRefCount(objvListPtr);

Tcl_ListObjAppendElement(interp, objvListPtr, ov);

Tcl_NRAddCallback(interp,

TclNRPackageObjCmdCleanup, objv[3], objvListPtr, NULL,NULL);

Tcl_ListObjAppendElement(interp, objvListPtr,

Tcl_DuplicateObj(newobjv[i]));

}

Tcl_NRAddCallback(interp,

TclNRPackageObjCmdCleanup, objv[2], objvListPtr, NULL,NULL);

Tcl_NRAddCallback(interp,

* in the Proc.

*/

if (result != TCL_OK) {

goto procError;

}

* Now divide the specifier up into name and default.

*/

&fieldValues);

if (result != TCL_OK) {

goto procError;

Tcl_WrongNumArgs(interp, 1, objv, "?level? command ?arg ...?");

return TCL_ERROR;

} else if (!TclHasStringRep(objv[1]) && objc == 2) {

status = Tcl_ListObjLength(interp, objv[1], &llength);

if (status == TCL_OK && llength > 1) {

/* the first argument can't interpreted as a level. Avoid

* length is not 2, then it cannot be converted to lambdaType.

*/

if ((result != TCL_OK) || ((objc != 2) && (objc != 3))) {

Tcl_SetObjResult(interp, Tcl_ObjPrintf(

"can't interpret \"%s\" as a lambda expression",

* Only return statuses of provided processes.

*/

if (result != TCL_OK) {

return result;

}

* Purge only provided processes.

*/

if (result != TCL_OK) {

return result;

}

Tcl_DictObjGet(NULL, iPtr->returnOpts, keys[KEY_ERRORSTACK],

&valuePtr);

if (valuePtr != NULL) {

Tcl_Obj **valueObjv;

if (Tcl_IsShared(iPtr->errorStack)) {

Tcl_DictObjGet(NULL, returnOpts, keys[KEY_ERRORCODE], &valuePtr);

if (valuePtr != NULL) {

if (TCL_ERROR == Tcl_ListObjLength(NULL, valuePtr, &length )) {

/*

Tcl_DictObjGet(NULL, returnOpts, keys[KEY_ERRORSTACK], &valuePtr);

if (valuePtr != NULL) {

/*

* Value is not a list, which is illegal for -errorstack.

*/

Tcl_Obj **objv, *mergedOpts;

Tcl_IncrRefCount(options);

|| (objc % 2)) {

Tcl_SetObjResult(interp, Tcl_ObjPrintf(

"expected dict but got \"%s\"", TclGetString(options)));

return TCL_ERROR;

}

if (TclHasInternalRep(objPtr, &tclListType)) {

/* A list can only be a (single) number if its length == 1 */

if (length != 1) {

return TCL_ERROR;

}

TclCheckEmptyString(

Tcl_Obj *objPtr)

{

if (objPtr->bytes == &tclEmptyString) {

return TCL_EMPTYSTRING_YES;

}

} while (seekingConversion);

}

code = Tcl_AppendFormatToObj(NULL, objPtr, format, objc, objv);

if (code != TCL_OK) {

Tcl_AppendPrintfToObj(objPtr,

#define TclUtfNext Tcl_UtfNext

#define TclUtfPrev Tcl_UtfPrev

#define TclBN_mp_add mp_add

#define TclBN_mp_add_d mp_add_d

Tcl_InvalidateStringRep, /* 42 */

Tcl_ListObjAppendList, /* 43 */

Tcl_ListObjAppendElement, /* 44 */

Tcl_ListObjIndex, /* 46 */

Tcl_ListObjReplace, /* 48 */

0, /* 49 */

Tcl_NewByteArrayObj, /* 50 */

Tcl_DictObjPut, /* 494 */

Tcl_DictObjGet, /* 495 */

Tcl_DictObjRemove, /* 496 */

Tcl_DictObjFirst, /* 498 */

Tcl_DictObjNext, /* 499 */

Tcl_DictObjDone, /* 500 */

0, /* 658 */

0, /* 659 */

Tcl_AsyncMarkFromSignal, /* 660 */

};

/* !END!: Do not edit above this line. */

Tcl_Interp *interp) /* Interpreter for application. */

{

Tcl_Obj **objv, *objPtr;

static const char *const specialOptions[] = {

"-appinitprocerror", "-appinitprocdeleteinterp",

"-appinitprocclosestderr", "-appinitprocsetrcfile", NULL

origPtr = SimpleRedirect(dirPtr);

res = Tcl_FSMatchInDirectory(interp, resPtr, origPtr, pattern, types);

if (res == TCL_OK) {

Tcl_ListObjLength(NULL, resPtr, &gLength);

for (j = 0; j < gLength; j++) {

Tcl_Obj *gElt, *nElt;

TCL_UNUSED(const char **) /*argv*/)

{

Tcl_Obj *list1Ptr, *list2Ptr, *emptyPtr, *concatPtr, *tmpPtr;

Tcl_Obj *objv[3];

/*

* pointer to its array of element pointers.

*/

if (result != TCL_OK) {

return result;

}

resultListPtr = Tcl_NewListObj(0, NULL);

FOREACH_COMMAND_TRACE(interp, name, clientData) {

Tcl_Obj *opObj, *eachTraceObjPtr, *elemObjPtr;

TraceCommandInfo *tcmdPtr = (TraceCommandInfo *)clientData;

* pointer to its array of element pointers.

*/

if (result != TCL_OK) {

return result;

}

resultListPtr = Tcl_NewListObj(0, NULL);

FOREACH_COMMAND_TRACE(interp, name, clientData) {

Tcl_Obj *opObj, *eachTraceObjPtr, *elemObjPtr;

TraceCommandInfo *tcmdPtr = (TraceCommandInfo *)clientData;

* pointer to its array of element pointers.

*/

if (result != TCL_OK) {

return result;

}

Tcl_Interp *interp, /* Interpreter to use for error reporting. If

* NULL, no error message is left. */

const char *list, /* Pointer to string with list structure. */

* number of elements in the list. */

const char ***argvPtr) /* Pointer to place to store pointer to array

* of pointers to list elements. */

{

const char **argv, *end, *element;

char *p;

/*

* Allocate enough space to work in. A (const char *) for each (possible)

if (*bytes != 'e') {

int numType;

const char *opPtr;

/* Value doesn't start with "e" */

Tcl_Obj *const objv[]) /* Argument objects. */

{

Tcl_Obj *varValuePtr, *newValuePtr;

Var *varPtr, *arrayPtr;

if (objc < 2) {

Tcl_WrongNumArgs(interp, 1, objv, "varName ?value ...?");

return TCL_ERROR;

}

} else {

if (result != TCL_OK) {

return result;

}

createdNewObj = 1;

}

if (result == TCL_OK) {

result = Tcl_ListObjReplace(interp, varValuePtr, numElems, 0,

(objc-2), (objv+2));

Tcl_Obj *varListObj, *arrayNameObj, *scriptObj;

ArraySearch *searchPtr = NULL;

Var *varPtr;

/*

* array for {k v} a body

Tcl_Obj *keyObj, *valueObj;

Var *varPtr;

Var *arrayPtr;

/*

* Process the result from the previous execution of the script body.

Tcl_Obj **nameObjPtr, *patternObj;

Tcl_HashSearch search;

const char *pattern;

switch (objc) {

case 2:

Tcl_Obj *arrayNameObj;

Tcl_Obj *arrayElemObj;

Var *varPtr, *arrayPtr;

if (objc != 3) {

Tcl_WrongNumArgs(interp, 1, objv, "arrayName list");

Tcl_Obj *keyPtr, *valuePtr;

Tcl_DictSearch search;

int done;

return TCL_ERROR;

}

/*

* Empty, so we'll just force the array to be properly existing

* instead.

* -compatibility reasons) a list.

*/

Tcl_Obj **elemPtrs, *copyListObj;

&elemLen, &elemPtrs);

if (result != TCL_OK) {

return result;

* there's no password protection. */

{

Tcl_Channel out;

long long directoryStartOffset;

/* The overall file offset of the start of the

* central directory. */

* may get less! */

{

ZlibStreamHandle *zshPtr = (ZlibStreamHandle *) zshandle;

Tcl_Obj *itemObj;

unsigned char *dataPtr, *itemPtr;

size_t existing = 0;

const char *const *pushOptions = pushDecompressOptions;

enum pushOptionsEnum {poDictionary, poHeader, poLevel, poLimit};

Tcl_Obj *headerObj = NULL, *compDictObj = NULL;

if (objc < 4) {

Tcl_WrongNumArgs(interp, 2, objv, "mode channel ?options...?");

TtyState *fsPtr = (TtyState *)instanceData;

size_t len, vlen;

TtyAttrs tty;

const char **argv;

struct termios iostate;

if ((len > 4) && (strncmp(optionName, "-ttycontrol", len) == 0)) {

#if defined(TIOCMGET) && defined(TIOCMSET)

if (Tcl_SplitList(interp, value, &argc, &argv) == TCL_ERROR) {

return TCL_ERROR;

if ((str != NULL) && (str[0] != '\0')) {

Tcl_DString ds;

const char **pathv;

char installLib[LIBRARY_SIZE];

Tcl_DString dString;

const WCHAR *actualName;

Tcl_Obj *srvListPtr = NULL, **srvPtrPtr = NULL;

ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);

/*

if (srcAttr & FILE_ATTRIBUTE_DIRECTORY) {

WCHAR *nativeSrcRest, *nativeDstRest;

const char **srcArgv, **dstArgv;

WCHAR nativeSrcPath[MAX_PATH];

WCHAR nativeDstPath[MAX_PATH];

Tcl_DString srcString, dstString;

int longShort, /* 0 to short name, 1 to long name. */

Tcl_Obj **attributePtrPtr) /* A pointer to return the object with. */

{

Tcl_Obj *splitPath;

size_t length;

Tcl_Obj *pathPtr,

const char *lib)

{

WCHAR wBuf[MAX_PATH];

char buf[MAX_PATH * 3];

Tcl_Obj *objPtr;

(DWORD) type, (BYTE *) &value, sizeof(DWORD));

} else if (type == REG_MULTI_SZ) {

Tcl_DString data, buf;

Tcl_Obj **objv;

if (Tcl_ListObjGetElements(interp, dataObj, &objc, &objv) != TCL_OK) {

size_t len, vlen;

Tcl_DString ds;

const WCHAR *native;

const char **argv;

infoPtr = (SerialInfo *) instanceData;