summaryrefslogtreecommitdiffstats
path: root/generic
diff options
context:
space:
mode:
authordkf <donal.k.fellows@manchester.ac.uk>2006-11-08 11:41:43 (GMT)
committerdkf <donal.k.fellows@manchester.ac.uk>2006-11-08 11:41:43 (GMT)
commitbcc3af0abdf3eaf53e455eff2df0907274932a85 (patch)
treec54a22502cd2f6166af1207600fea5cee67e85c8 /generic
parenta62a213bf0ec0c03cf8ba72b4d91fedced21f9a2 (diff)
downloadtcl-bcc3af0abdf3eaf53e455eff2df0907274932a85.zip
tcl-bcc3af0abdf3eaf53e455eff2df0907274932a85.tar.gz
tcl-bcc3af0abdf3eaf53e455eff2df0907274932a85.tar.bz2
Rewrite for style and clarity (esp. tclPkg.c)
Diffstat (limited to 'generic')
-rw-r--r--generic/tclIO.c506
-rw-r--r--generic/tclPkg.c906
2 files changed, 788 insertions, 624 deletions
diff --git a/generic/tclIO.c b/generic/tclIO.c
index 689447b..9016cef 100644
--- a/generic/tclIO.c
+++ b/generic/tclIO.c
@@ -10,7 +10,7 @@
* See the file "license.terms" for information on usage and redistribution of
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tclIO.c,v 1.109 2006/09/28 19:24:52 msofer Exp $
+ * RCS: @(#) $Id: tclIO.c,v 1.110 2006/11/08 11:41:44 dkf Exp $
*/
#include "tclInt.h"
@@ -120,7 +120,7 @@ static int WriteBytes(Channel *chanPtr, CONST char *src,
int srcLen);
static int WriteChars(Channel *chanPtr, CONST char *src,
int srcLen);
-static Tcl_Obj * FixLevelCode(Tcl_Obj* msg);
+static Tcl_Obj * FixLevelCode(Tcl_Obj *msg);
static void SpliceChannel(Tcl_Channel chan);
static void CutChannel(Tcl_Channel chan);
@@ -177,7 +177,7 @@ TclFinalizeIOSubsystem(void)
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
Channel *chanPtr; /* Iterates over open channels. */
ChannelState *nextCSPtr; /* Iterates over open channels. */
- ChannelState *statePtr; /* state of channel stack */
+ ChannelState *statePtr; /* State of channel stack */
/*
* Walk all channel state structures known to this thread and
@@ -211,6 +211,7 @@ TclFinalizeIOSubsystem(void)
* Preserve statePtr from disappearing until we can get the
* nextCSPtr below.
*/
+
Tcl_Preserve(statePtr);
if (statePtr->refCount <= 0) {
/*
@@ -248,10 +249,12 @@ TclFinalizeIOSubsystem(void)
chanPtr->instanceData = NULL;
statePtr->flags |= CHANNEL_DEAD;
}
+
/*
* We look for the next pointer now in case we had one closed on up
* during the current channel's closeproc (eg: rechan extension)
*/
+
nextCSPtr = statePtr->nextCSPtr;
Tcl_Release(statePtr);
}
@@ -343,7 +346,7 @@ Tcl_GetStdChannel(
*/
if (tsdPtr->stdinChannel != NULL) {
- (void) Tcl_RegisterChannel(NULL, tsdPtr->stdinChannel);
+ Tcl_RegisterChannel(NULL, tsdPtr->stdinChannel);
}
}
channel = tsdPtr->stdinChannel;
@@ -353,7 +356,7 @@ Tcl_GetStdChannel(
tsdPtr->stdoutChannel = TclpGetDefaultStdChannel(TCL_STDOUT);
tsdPtr->stdoutInitialized = 1;
if (tsdPtr->stdoutChannel != NULL) {
- (void) Tcl_RegisterChannel(NULL, tsdPtr->stdoutChannel);
+ Tcl_RegisterChannel(NULL, tsdPtr->stdoutChannel);
}
}
channel = tsdPtr->stdoutChannel;
@@ -363,7 +366,7 @@ Tcl_GetStdChannel(
tsdPtr->stderrChannel = TclpGetDefaultStdChannel(TCL_STDERR);
tsdPtr->stderrInitialized = 1;
if (tsdPtr->stderrChannel != NULL) {
- (void) Tcl_RegisterChannel(NULL, tsdPtr->stderrChannel);
+ Tcl_RegisterChannel(NULL, tsdPtr->stderrChannel);
}
}
channel = tsdPtr->stderrChannel;
@@ -483,14 +486,12 @@ GetChannelTable(
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
Tcl_Channel stdinChan, stdoutChan, stderrChan;
- hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
+ hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL);
if (hTblPtr == NULL) {
hTblPtr = (Tcl_HashTable *) ckalloc(sizeof(Tcl_HashTable));
Tcl_InitHashTable(hTblPtr, TCL_STRING_KEYS);
-
- (void) Tcl_SetAssocData(interp, "tclIO",
- (Tcl_InterpDeleteProc *) DeleteChannelTable,
- (ClientData) hTblPtr);
+ Tcl_SetAssocData(interp, "tclIO",
+ (Tcl_InterpDeleteProc *) DeleteChannelTable, hTblPtr);
/*
* If the interpreter is trusted (not "safe"), insert channels for
@@ -929,7 +930,7 @@ DetachChannel(
statePtr = chanPtr->state;
if (interp != NULL) {
- hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
+ hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL);
if (hTblPtr == NULL) {
return TCL_ERROR;
}
@@ -1100,6 +1101,7 @@ Tcl_CreateChannel(
if (chanName != NULL) {
char *tmp = ckalloc((unsigned) (strlen(chanName) + 1));
+
statePtr->channelName = tmp;
strcpy(tmp, chanName);
} else {
@@ -1332,6 +1334,7 @@ Tcl_StackChannel(
statePtr->csPtr = csPtr;
}
+
/*
* Discard any input in the buffers. They are not yet read by the user of
* the channel, so they have to go through the new transformation before
@@ -1468,6 +1471,7 @@ Tcl_UnstackChannel(
if (Tcl_Flush((Tcl_Channel) chanPtr) != TCL_OK) {
statePtr->csPtr = csPtr;
+
/*
* TIP #219, Tcl Channel Reflection API.
* Move error messages put by the driver into the chan/ip
@@ -1475,6 +1479,7 @@ Tcl_UnstackChannel(
* to the regular message if nothing was found in the
* bypasses.
*/
+
if (!TclChanCaughtErrorBypass(interp, chan) && interp) {
Tcl_AppendResult(interp, "could not flush channel \"",
Tcl_GetChannelName((Tcl_Channel) chanPtr), "\"",
@@ -1627,7 +1632,8 @@ Tcl_Channel
Tcl_GetStackedChannel(
Tcl_Channel chan)
{
- Channel *chanPtr = (Channel *) chan; /* The actual channel. */
+ Channel *chanPtr = (Channel *) chan;
+ /* The actual channel. */
return (Tcl_Channel) chanPtr->downChanPtr;
}
@@ -1654,7 +1660,8 @@ Tcl_Channel
Tcl_GetTopChannel(
Tcl_Channel chan)
{
- Channel *chanPtr = (Channel *) chan; /* The actual channel. */
+ Channel *chanPtr = (Channel *) chan;
+ /* The actual channel. */
return (Tcl_Channel) chanPtr->state->topChanPtr;
}
@@ -1679,7 +1686,8 @@ ClientData
Tcl_GetChannelInstanceData(
Tcl_Channel chan) /* Channel for which to return client data. */
{
- Channel *chanPtr = (Channel *) chan; /* The actual channel. */
+ Channel *chanPtr = (Channel *) chan;
+ /* The actual channel. */
return chanPtr->instanceData;
}
@@ -1705,7 +1713,8 @@ Tcl_GetChannelThread(
Tcl_Channel chan) /* The channel to return the managing thread
* for. */
{
- Channel *chanPtr = (Channel *) chan; /* The actual channel. */
+ Channel *chanPtr = (Channel *) chan;
+ /* The actual channel. */
return chanPtr->state->managingThread;
}
@@ -2081,10 +2090,11 @@ FlushChannel(
*/
if (((statePtr->curOutPtr != NULL) &&
- (statePtr->curOutPtr->nextAdded == statePtr->curOutPtr->bufLength))
+ (statePtr->curOutPtr->nextAdded
+ == statePtr->curOutPtr->bufLength))
|| ((statePtr->flags & BUFFER_READY) &&
(statePtr->outQueueHead == NULL))) {
- statePtr->flags &= (~(BUFFER_READY));
+ statePtr->flags &= ~BUFFER_READY;
statePtr->curOutPtr->nextPtr = NULL;
if (statePtr->outQueueHead == NULL) {
statePtr->outQueueHead = statePtr->curOutPtr;
@@ -2175,7 +2185,7 @@ FlushChannel(
if (statePtr->unreportedError == 0) {
statePtr->unreportedError = errorCode;
- statePtr->unreportedMsg = msg;
+ statePtr->unreportedMsg = msg;
if (msg != NULL) {
Tcl_IncrRefCount(msg);
}
@@ -2187,7 +2197,7 @@ FlushChannel(
statePtr->chanMsg = NULL;
if (msg != NULL) {
- Tcl_DecrRefCount(msg);
+ TclDecrRefCount(msg);
}
}
} else {
@@ -2199,18 +2209,18 @@ FlushChannel(
*/
Tcl_SetErrno(errorCode);
- if (interp != NULL) {
- if (!TclChanCaughtErrorBypass(interp, (Tcl_Channel) chanPtr)) {
- /*
- * Casting away CONST here is safe because the
- * TCL_VOLATILE flag guarantees CONST treatment of the
- * Posix error string.
- */
+ if (interp != NULL && !TclChanCaughtErrorBypass(interp,
+ (Tcl_Channel) chanPtr)) {
+ /*
+ * Casting away CONST here is safe because the
+ * TCL_VOLATILE flag guarantees CONST treatment of the
+ * Posix error string.
+ */
- Tcl_SetResult(interp,
- (char *) Tcl_PosixError(interp), TCL_VOLATILE);
- }
+ Tcl_SetResult(interp, (char *) Tcl_PosixError(interp),
+ TCL_VOLATILE);
}
+
/*
* An unreportable bypassed message is kept, for the caller of
* Tcl_Seek, Tcl_Write, etc.
@@ -2254,7 +2264,7 @@ FlushChannel(
if (wroteSome) {
return errorCode;
} else if (statePtr->outQueueHead == NULL) {
- statePtr->flags &= (~(BG_FLUSH_SCHEDULED));
+ statePtr->flags &= ~BG_FLUSH_SCHEDULED;
(chanPtr->typePtr->watchProc)(chanPtr->instanceData,
statePtr->interestMask);
}
@@ -2360,7 +2370,7 @@ CloseChannel(
if (interp != NULL) {
Tcl_SetChannelErrorInterp(interp,statePtr->chanMsg);
}
- Tcl_DecrRefCount(statePtr->chanMsg);
+ TclDecrRefCount(statePtr->chanMsg);
statePtr->chanMsg = NULL;
}
@@ -2408,13 +2418,14 @@ CloseChannel(
if (statePtr->unreportedError != 0) {
errorCode = statePtr->unreportedError;
- /* TIP #219, Tcl Channel Reflection API.
+ /*
+ * TIP #219, Tcl Channel Reflection API.
* Move an error message found in the unreported area into the regular
* bypass (interp). This kills any message in the channel bypass area.
*/
if (statePtr->chanMsg != NULL) {
- Tcl_DecrRefCount(statePtr->chanMsg);
+ TclDecrRefCount(statePtr->chanMsg);
statePtr->chanMsg = NULL;
}
if (interp) {
@@ -2502,7 +2513,7 @@ CutChannel(
* states - used to splice a channel out of
* the list on close. */
ChannelState *statePtr = ((Channel *) chan)->state;
- /* state of the channel stack. */
+ /* State of the channel stack. */
Tcl_DriverThreadActionProc *threadActionProc;
/*
@@ -2542,13 +2553,13 @@ Tcl_CutChannel(
Tcl_Channel chan) /* The channel being added. Must not be
* referenced in any interpreter. */
{
- Channel* chanPtr = ((Channel*) chan)->state->bottomChanPtr;
+ Channel *chanPtr = ((Channel *) chan)->state->bottomChanPtr;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
ChannelState *prevCSPtr; /* Preceding channel state in list of all
* states - used to splice a channel out of
* the list on close. */
ChannelState *statePtr = chanPtr->state;
- /* state of the channel stack. */
+ /* State of the channel stack. */
Tcl_DriverThreadActionProc *threadActionProc;
/*
@@ -2779,7 +2790,7 @@ Tcl_Close(
if (interp != NULL) {
Tcl_SetChannelErrorInterp(interp,statePtr->chanMsg);
}
- Tcl_DecrRefCount(statePtr->chanMsg);
+ TclDecrRefCount(statePtr->chanMsg);
statePtr->chanMsg = NULL;
}
}
@@ -2836,7 +2847,7 @@ Tcl_Close(
* them into the regular interpreter result.
*
* Notes: Due to the assertion of CHANNEL_CLOSED in the flags
- * "FlushChannel" has called "CloseChannel" and thus freed all the channel
+ * FlushChannel() has called CloseChannel() and thus freed all the channel
* structures. We must not try to access "chan" anymore, hence the NULL
* argument in the call below. The only place which may still contain a
* message is the interpreter itself, and "CloseChannel" made sure to lift
@@ -2982,7 +2993,7 @@ Tcl_Write(
*/
Channel *chanPtr;
- ChannelState *statePtr; /* state info for channel */
+ ChannelState *statePtr; /* State info for channel */
statePtr = ((Channel *) chan)->state;
chanPtr = statePtr->topChanPtr;
@@ -3029,7 +3040,8 @@ Tcl_WriteRaw(
* strlen(). */
{
Channel *chanPtr = ((Channel *) chan);
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
int errorCode, written;
if (CheckChannelErrors(statePtr, TCL_WRITABLE | CHANNEL_RAW_MODE) != 0) {
@@ -3086,7 +3098,7 @@ Tcl_WriteChars(
int len) /* Length of string in bytes, or < 0 for
* strlen(). */
{
- ChannelState *statePtr; /* state info for channel */
+ ChannelState *statePtr; /* State info for channel */
statePtr = ((Channel *) chan)->state;
@@ -3132,7 +3144,7 @@ DoWriteChars(
* Always use the topmost channel of the stack
*/
- ChannelState *statePtr; /* state info for channel */
+ ChannelState *statePtr; /* State info for channel */
statePtr = chanPtr->state;
chanPtr = statePtr->topChanPtr;
@@ -3193,7 +3205,7 @@ Tcl_WriteObj(
*/
Channel *chanPtr;
- ChannelState *statePtr; /* state info for channel */
+ ChannelState *statePtr; /* State info for channel */
char *src;
int srcLen;
@@ -3239,7 +3251,8 @@ WriteBytes(
CONST char *src, /* Bytes to write. */
int srcLen) /* Number of bytes to write. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr;
char *dst;
int dstMax, sawLF, savedLF, total, dstLen, toWrite;
@@ -3328,7 +3341,8 @@ WriteChars(
CONST char *src, /* UTF-8 string to write. */
int srcLen) /* Length of UTF-8 string in bytes. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr;
char *dst, *stage;
int saved, savedLF, sawLF, total, dstLen, stageMax, dstWrote;
@@ -3413,7 +3427,7 @@ WriteChars(
* that we need to stick at the beginning of this buffer.
*/
- memcpy((VOID *) dst, (VOID *) safe, (size_t) saved);
+ memcpy(dst, safe, (size_t) saved);
bufPtr->nextAdded += saved;
dst += saved;
dstLen -= saved;
@@ -3425,7 +3439,8 @@ WriteChars(
&statePtr->outputEncodingState, dst,
dstLen + BUFFER_PADDING, &stageRead, &dstWrote, NULL);
- /* Fix for SF #506297, reported by Martin Forssen
+ /*
+ * Fix for SF #506297, reported by Martin Forssen
* <ruric@users.sourceforge.net>.
*
* The encoding chosen in the script exposing the bug writes out
@@ -3470,7 +3485,7 @@ WriteChars(
*/
saved = bufPtr->nextAdded - bufPtr->bufLength;
- memcpy((VOID *) safe, (VOID *) (dst + dstLen), (size_t) saved);
+ memcpy(safe, dst + dstLen, (size_t) saved);
bufPtr->nextAdded = bufPtr->bufLength;
}
if (CheckFlush(chanPtr, bufPtr, sawLF) != 0) {
@@ -3656,7 +3671,9 @@ CheckFlush(
int newlineFlag) /* Non-zero if a the channel buffer contains a
* newline. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
+
/*
* The current buffer is ready for output:
* 1. if it is full.
@@ -3755,7 +3772,8 @@ Tcl_GetsObj(
{
GetsState gs;
Channel *chanPtr = (Channel *) chan;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr;
int inEofChar, skip, copiedTotal, oldLength, oldFlags, oldRemoved;
Tcl_Encoding encoding;
@@ -3963,7 +3981,7 @@ Tcl_GetsObj(
*/
dstEnd = eof;
- statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+ statePtr->flags |= CHANNEL_EOF | CHANNEL_STICKY_EOF;
statePtr->inputEncodingFlags |= TCL_ENCODING_END;
}
if (statePtr->flags & CHANNEL_EOF) {
@@ -4091,10 +4109,10 @@ FilterInputBytes(
Channel *chanPtr, /* Channel to read. */
GetsState *gsPtr) /* Current state of gets operation. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr;
- char *raw, *rawStart, *rawEnd;
- char *dst;
+ char *raw, *rawStart, *rawEnd, *dst;
int offset, toRead, dstNeeded, spaceLeft, result, rawLen, length;
Tcl_Obj *objPtr;
#define ENCODING_LINESIZE 20 /* Lower bound on how many bytes to convert at
@@ -4228,8 +4246,8 @@ FilterInputBytes(
statePtr->inQueueTail = nextPtr;
}
extra = rawLen - gsPtr->rawRead;
- memcpy((VOID *) (nextPtr->buf + BUFFER_PADDING - extra),
- (VOID *) (raw + gsPtr->rawRead), (size_t) extra);
+ memcpy(nextPtr->buf + BUFFER_PADDING - extra,
+ raw + gsPtr->rawRead, (size_t) extra);
nextPtr->nextRemoved -= extra;
bufPtr->nextAdded -= extra;
}
@@ -4268,7 +4286,8 @@ PeekAhead(
* UTF-8 characters. */
GetsState *gsPtr) /* Current state of gets operation. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr;
Tcl_DriverBlockModeProc *blockModeProc;
int bytesLeft;
@@ -4345,7 +4364,8 @@ CommonGetsCleanup(
Channel *chanPtr,
Tcl_Encoding encoding)
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr, *nextPtr;
bufPtr = statePtr->inQueueHead;
@@ -4375,8 +4395,8 @@ CommonGetsCleanup(
extra = bufPtr->bufLength - bufPtr->nextAdded;
if (extra > 0) {
- memcpy((VOID *) (bufPtr->buf + bufPtr->nextAdded),
- (VOID *) (nextPtr->buf + BUFFER_PADDING - extra),
+ memcpy(bufPtr->buf + bufPtr->nextAdded,
+ nextPtr->buf + BUFFER_PADDING - extra,
(size_t) extra);
bufPtr->nextAdded += extra;
nextPtr->nextRemoved = BUFFER_PADDING;
@@ -4418,7 +4438,8 @@ Tcl_Read(
int bytesToRead) /* Maximum number of bytes to read. */
{
Channel *chanPtr = (Channel *) chan;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
/*
* This operation should occur at the top of a channel stack.
@@ -4462,9 +4483,9 @@ Tcl_ReadRaw(
int bytesToRead) /* Maximum number of bytes to read. */
{
Channel *chanPtr = (Channel *) chan;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
- int nread, result;
- int copied, copiedNow;
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
+ int nread, result, copied, copiedNow;
/*
* The check below does too much because it will reject a call to this
@@ -4499,13 +4520,13 @@ Tcl_ReadRaw(
if (statePtr->flags & CHANNEL_NONBLOCKING) {
goto done;
}
- statePtr->flags &= (~(CHANNEL_BLOCKED));
+ statePtr->flags &= ~CHANNEL_BLOCKED;
}
#ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING
/*
- * [SF Tcl Bug 943274]. Better emulation of non-blocking channels
- * for channels without BlockModeProc, by keeping track of true
+ * [Bug 943274]. Better emulation of non-blocking channels for
+ * channels without BlockModeProc, by keeping track of true
* fileevents generated by the OS == Data waiting and reading if
* and only if we are sure to have data.
*/
@@ -4541,11 +4562,10 @@ Tcl_ReadRaw(
if (nread > 0) {
/*
- * If we get a short read, signal up that we may be
- * BLOCKED. We should avoid calling the driver because
- * on some platforms we will block in the low level
- * reading code even though the channel is set into
- * nonblocking mode.
+ * If we get a short read, signal up that we may be BLOCKED.
+ * We should avoid calling the driver because on some
+ * platforms we will block in the low level reading code even
+ * though the channel is set into nonblocking mode.
*/
if (nread < (bytesToRead - copied)) {
@@ -4555,8 +4575,8 @@ Tcl_ReadRaw(
#ifdef TCL_IO_TRACK_OS_FOR_DRIVER_WITH_BAD_BLOCKING
if (nread <= (bytesToRead - copied)) {
/*
- * [SF Tcl Bug 943274] We have read the available data,
- * clear flag.
+ * [Bug 943274] We have read the available data, clear
+ * flag.
*/
statePtr->flags &= ~CHANNEL_HAS_MORE_DATA;
@@ -4629,7 +4649,8 @@ Tcl_ReadChars(
* of the object. */
{
Channel *chanPtr = (Channel *) chan;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
/*
* This operation should occur at the top of a channel stack.
@@ -4683,7 +4704,8 @@ DoReadChars(
* the data will replace the existing contents
* of the object. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *bufPtr;
int offset, factor, copied, copiedNow, result;
Tcl_Encoding encoding;
@@ -5001,40 +5023,38 @@ ReadChars(
* multi-byte character at the end (only the first byte of it).
* - Encoding translation fails, asks for more data
* - Data is read, and eof is reached, TCL_ENCODING_END (TEE) is set.
- * - ReadChar is called again, converts the first buffer, but due
- * to TEE it does not check for incomplete multi-byte data, and the
- * character just after the end of the first buffer is a valid
- * completion of the multi-byte header in the actual buffer. The
- * conversion reads more characters from the buffer then present.
- * This causes nextRemoved to overshoot nextAdded and the next
- * reads compute a negative srcLen, cause further translations to
- * fail, causing copying of data into the next buffer using bad
- * arguments, causing the mecpy for to eventually fail.
+ * - ReadChar is called again, converts the first buffer, but due to TEE
+ * it does not check for incomplete multi-byte data, and the character
+ * just after the end of the first buffer is a valid completion of the
+ * multi-byte header in the actual buffer. The conversion reads more
+ * characters from the buffer then present. This causes nextRemoved to
+ * overshoot nextAdded and the next reads compute a negative srcLen,
+ * cause further translations to fail, causing copying of data into the
+ * next buffer using bad arguments, causing the mecpy for to eventually
+ * fail.
*
- * In the end it is a memory access bug spiraling out of control
- * if the conditions are _just so_. And ultimate cause is that TEE
- * is given to a conversion where it should not. TEE signals that
- * this is the last buffer. Except in our case it is not.
+ * In the end it is a memory access bug spiraling out of control if the
+ * conditions are _just so_. And ultimate cause is that TEE is given to a
+ * conversion where it should not. TEE signals that this is the last
+ * buffer. Except in our case it is not.
*
- * My solution is to suppress TEE if the first buffer is not the
- * last. We will eventually need it given that EOF has been
- * reached, but not right now. This is what the new flag
- * "endEncSuppressFlag" is for.
+ * My solution is to suppress TEE if the first buffer is not the last. We
+ * will eventually need it given that EOF has been reached, but not right
+ * now. This is what the new flag "endEncSuppressFlag" is for.
*
- * The bug in 'Tcl_Utf2UtfProc' where it read from memory behind
- * the actual buffer has been fixed as well, and fixes the problem
- * with the crash too, but this would still allow the generic
- * layer to accidentially break a multi-byte sequence if the
- * conditions are just right, because again the ExternalToUtf
- * would be successful where it should not.
+ * The bug in 'Tcl_Utf2UtfProc' where it read from memory behind the
+ * actual buffer has been fixed as well, and fixes the problem with the
+ * crash too, but this would still allow the generic layer to
+ * accidentially break a multi-byte sequence if the conditions are just
+ * right, because again the ExternalToUtf would be successful where it
+ * should not.
*/
if ((statePtr->inputEncodingFlags & TCL_ENCODING_END) &&
- (bufPtr->nextPtr != NULL)) {
-
- /* TEE is set for a buffer which is not the last. Squash it
- * for now, and restore it later, before yielding control to
- * our caller.
+ (bufPtr->nextPtr != NULL)) {
+ /*
+ * TEE is set for a buffer which is not the last. Squash it for now,
+ * and restore it later, before yielding control to our caller.
*/
statePtr->inputEncodingFlags &= ~TCL_ENCODING_END;
@@ -5096,9 +5116,7 @@ ReadChars(
/*
* There isn't enough data in the buffers to complete the next
* character, so we need to wait for more data before the next
- * file event can be delivered.
- *
- * SF #478856.
+ * file event can be delivered. [Bug 478856]
*
* The exception to this is if the input buffer was completely
* empty before we tried to convert its contents. Nothing in,
@@ -5111,25 +5129,25 @@ ReadChars(
return -1;
}
- /* Space is made at the beginning of the buffer to copy the
- * previous unused bytes there. Check first if the buffer we
- * are using actually has enough space at its beginning for
- * the data we are copying. Because if not we will write over the
- * buffer management information, especially the 'nextPtr'.
+ /*
+ * Space is made at the beginning of the buffer to copy the previous
+ * unused bytes there. Check first if the buffer we are using actually
+ * has enough space at its beginning for the data we are copying.
+ * Because if not we will write over the buffer management
+ * information, especially the 'nextPtr'.
*
- * Note that the BUFFER_PADDING (See AllocChannelBuffer) is
- * used to prevent exactly this situation. I.e. it should
- * never happen. Therefore it is ok to panic should it happen
- * despite the precautions.
+ * Note that the BUFFER_PADDING (See AllocChannelBuffer) is used to
+ * prevent exactly this situation. I.e. it should never happen.
+ * Therefore it is ok to panic should it happen despite the
+ * precautions.
*/
if (nextPtr->nextRemoved - srcLen < 0) {
- Tcl_Panic ("Buffer Underflow, BUFFER_PADDING not enough");
+ Tcl_Panic("Buffer Underflow, BUFFER_PADDING not enough");
}
nextPtr->nextRemoved -= srcLen;
- memcpy((VOID *) (nextPtr->buf + nextPtr->nextRemoved), (VOID *) src,
- (size_t) srcLen);
+ memcpy(nextPtr->buf + nextPtr->nextRemoved, src, (size_t) srcLen);
RecycleBuffer(statePtr, bufPtr, 0);
statePtr->inQueueHead = nextPtr;
return ReadChars(statePtr, objPtr, charsToRead, offsetPtr, factorPtr);
@@ -5255,7 +5273,7 @@ TranslateInputEOL(
switch (statePtr->inputTranslation) {
case TCL_TRANSLATE_LF:
if (dstStart != srcStart) {
- memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen);
+ memcpy(dstStart, srcStart, (size_t) dstLen);
}
srcLen = dstLen;
break;
@@ -5263,7 +5281,7 @@ TranslateInputEOL(
char *dst, *dstEnd;
if (dstStart != srcStart) {
- memcpy((VOID *) dstStart, (VOID *) srcStart, (size_t) dstLen);
+ memcpy(dstStart, srcStart, (size_t) dstLen);
}
dstEnd = dstStart + dstLen;
for (dst = dstStart; dst < dstEnd; dst++) {
@@ -5348,7 +5366,7 @@ TranslateInputEOL(
* character in the output string.
*/
- statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+ statePtr->flags |= CHANNEL_EOF | CHANNEL_STICKY_EOF;
statePtr->inputEncodingFlags |= TCL_ENCODING_END;
statePtr->flags &= ~(INPUT_SAW_CR | INPUT_NEED_NL);
return 1;
@@ -5418,7 +5436,7 @@ Tcl_Ungets(
if (statePtr->flags & CHANNEL_STICKY_EOF) {
goto done;
}
- statePtr->flags &= (~(CHANNEL_BLOCKED | CHANNEL_EOF));
+ statePtr->flags &= ~(CHANNEL_BLOCKED | CHANNEL_EOF);
bufPtr = AllocChannelBuffer(len);
for (i = 0; i < len; i++) {
@@ -5527,7 +5545,8 @@ DiscardInputQueued(
int discardSavedBuffers) /* If non-zero, discard all buffers including
* last one. */
{
- ChannelBuffer *bufPtr, *nxtPtr; /* Loop variables. */
+ ChannelBuffer *bufPtr, *nxtPtr;
+ /* Loop variables. */
bufPtr = statePtr->inQueueHead;
statePtr->inQueueHead = NULL;
@@ -5573,7 +5592,8 @@ GetInput(
int result; /* Of calling driver. */
int nread; /* How much was read from channel? */
ChannelBuffer *bufPtr; /* New buffer to add to input queue. */
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
/*
* Prevent reading from a dead channel -- a channel that has been closed
@@ -5628,10 +5648,9 @@ GetInput(
statePtr->saveInBufPtr = NULL;
/*
- * Check the actual buffersize against the requested
- * buffersize. Buffers which are smaller than requested are
- * squashed. This is done to honor dynamic changes of the buffersize
- * made by the user.
+ * Check the actual buffersize against the requested buffersize.
+ * Buffers which are smaller than requested are squashed. This is done
+ * to honor dynamic changes of the buffersize made by the user.
*/
if ((bufPtr != NULL)
@@ -5768,8 +5787,10 @@ Tcl_Seek(
Tcl_WideInt offset, /* Offset to seek to. */
int mode) /* Relative to which location to seek? */
{
- Channel *chanPtr = (Channel *) chan; /* The real IO channel. */
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ Channel *chanPtr = (Channel *) chan;
+ /* The real IO channel. */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
int inputBuffered, outputBuffered;
/* # bytes held in buffers. */
int result; /* Of device driver operations. */
@@ -5860,9 +5881,9 @@ Tcl_Seek(
if (result != 0) {
return Tcl_LongAsWide(-1);
}
- statePtr->flags &= (~(CHANNEL_NONBLOCKING));
+ statePtr->flags &= ~CHANNEL_NONBLOCKING;
if (statePtr->flags & BG_FLUSH_SCHEDULED) {
- statePtr->flags &= (~(BG_FLUSH_SCHEDULED));
+ statePtr->flags &= ~BG_FLUSH_SCHEDULED;
}
}
@@ -5953,8 +5974,10 @@ Tcl_WideInt
Tcl_Tell(
Tcl_Channel chan) /* The channel to return pos for. */
{
- Channel *chanPtr = (Channel *) chan; /* The real IO channel. */
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ Channel *chanPtr = (Channel *) chan;
+ /* The real IO channel. */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
int inputBuffered, outputBuffered;
/* # bytes held in buffers. */
int result; /* Of calling device driver. */
@@ -6103,6 +6126,7 @@ Tcl_TruncateChannel(
* Feature not supported and it's not emulatable. Pretend it's
* returned an EINVAL, a very generic error!
*/
+
Tcl_SetErrno(EINVAL);
return TCL_ERROR;
}
@@ -6112,6 +6136,7 @@ Tcl_TruncateChannel(
* We require that the file was opened of writing. Do that check now
* so that we only flush if we think we're going to succeed.
*/
+
Tcl_SetErrno(EINVAL);
return TCL_ERROR;
}
@@ -6180,7 +6205,7 @@ CheckChannelErrors(
*/
if (statePtr->chanMsg != NULL) {
- Tcl_DecrRefCount(statePtr->chanMsg);
+ TclDecrRefCount(statePtr->chanMsg);
}
statePtr->chanMsg = statePtr->unreportedMsg;
statePtr->unreportedMsg = NULL;
@@ -6400,7 +6425,7 @@ Tcl_ChannelBuffered(
Tcl_Channel chan) /* The channel to query. */
{
Channel *chanPtr = (Channel *) chan;
- /* real channel structure. */
+ /* Real channel structure. */
ChannelBuffer *bufPtr;
int bytesBuffered;
@@ -6441,10 +6466,7 @@ Tcl_SetChannelBufferSize(
* not accept the requested size and leave the current buffer size.
*/
- if (sz < 1) {
- return;
- }
- if (sz > (1024 * 1024)) {
+ if (sz < 1 || sz > 1024*1024) {
return;
}
@@ -6587,7 +6609,8 @@ Tcl_GetChannelOption(
size_t len; /* Length of optionName string. */
char optionVal[128]; /* Buffer for sprintf. */
Channel *chanPtr = (Channel *) chan;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
int flags;
/*
@@ -6819,8 +6842,10 @@ Tcl_SetChannelOption(
CONST char *optionName, /* Which option to set? */
CONST char *newValue) /* New value for option. */
{
- Channel *chanPtr = (Channel *) chan; /* The real IO channel. */
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ Channel *chanPtr = (Channel *) chan;
+ /* The real IO channel. */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
size_t len; /* Length of optionName string. */
int argc;
CONST char **argv;
@@ -6873,14 +6898,14 @@ Tcl_SetChannelOption(
len = strlen(newValue);
if ((newValue[0] == 'f') && (strncmp(newValue, "full", len) == 0)) {
statePtr->flags &=
- (~(CHANNEL_UNBUFFERED|CHANNEL_LINEBUFFERED));
+ ~(CHANNEL_UNBUFFERED|CHANNEL_LINEBUFFERED);
} else if ((newValue[0] == 'l') &&
(strncmp(newValue, "line", len) == 0)) {
- statePtr->flags &= (~(CHANNEL_UNBUFFERED));
+ statePtr->flags &= ~CHANNEL_UNBUFFERED;
statePtr->flags |= CHANNEL_LINEBUFFERED;
} else if ((newValue[0] == 'n') &&
(strncmp(newValue, "none", len) == 0)) {
- statePtr->flags &= (~(CHANNEL_LINEBUFFERED));
+ statePtr->flags &= ~CHANNEL_LINEBUFFERED;
statePtr->flags |= CHANNEL_UNBUFFERED;
} else {
if (interp) {
@@ -7035,8 +7060,7 @@ Tcl_SetChannelOption(
if (translation != statePtr->inputTranslation) {
statePtr->inputTranslation = translation;
- statePtr->flags &= ~(INPUT_SAW_CR);
- statePtr->flags &= ~(CHANNEL_NEED_MORE_DATA);
+ statePtr->flags &= ~(INPUT_SAW_CR | CHANNEL_NEED_MORE_DATA);
UpdateInterest(chanPtr);
}
}
@@ -7096,14 +7120,13 @@ Tcl_SetChannelOption(
RecycleBuffer(statePtr, statePtr->saveInBufPtr, 1);
statePtr->saveInBufPtr = NULL;
}
- if (statePtr->inQueueHead != NULL) {
- if ((statePtr->inQueueHead->nextPtr == NULL)
- && (statePtr->inQueueHead->nextAdded ==
- statePtr->inQueueHead->nextRemoved)) {
- RecycleBuffer(statePtr, statePtr->inQueueHead, 1);
- statePtr->inQueueHead = NULL;
- statePtr->inQueueTail = NULL;
- }
+ if ((statePtr->inQueueHead != NULL)
+ && (statePtr->inQueueHead->nextPtr == NULL)
+ && (statePtr->inQueueHead->nextAdded ==
+ statePtr->inQueueHead->nextRemoved)) {
+ RecycleBuffer(statePtr, statePtr->inQueueHead, 1);
+ statePtr->inQueueHead = NULL;
+ statePtr->inQueueTail = NULL;
}
/*
@@ -7145,7 +7168,8 @@ CleanupChannelHandlers(
Tcl_Interp *interp,
Channel *chanPtr)
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
EventScriptRecord *sPtr, *prevPtr, *nextPtr;
/*
@@ -7200,7 +7224,8 @@ Tcl_NotifyChannel(
* which events were detected. */
{
Channel *chanPtr = (Channel *) channel;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelHandler *chPtr;
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
NextChannelHandler nh;
@@ -7346,7 +7371,8 @@ static void
UpdateInterest(
Channel *chanPtr) /* Channel to update. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
int mask = statePtr->interestMask;
/*
@@ -7443,7 +7469,8 @@ ChannelTimerProc(
ClientData clientData)
{
Channel *chanPtr = (Channel *) clientData;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
if (!(statePtr->flags & CHANNEL_NEED_MORE_DATA)
&& (statePtr->interestMask & TCL_READABLE)
@@ -7522,7 +7549,8 @@ Tcl_CreateChannelHandler(
{
ChannelHandler *chPtr;
Channel *chanPtr = (Channel *) chan;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
/*
* Check whether this channel handler is not already registered. If it is
@@ -7595,7 +7623,8 @@ Tcl_DeleteChannelHandler(
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
ChannelHandler *chPtr, *prevChPtr;
Channel *chanPtr = (Channel *) chan;
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
NextChannelHandler *nhPtr;
/*
@@ -7681,7 +7710,8 @@ DeleteScriptRecord(
int mask) /* Events in mask must exactly match mask of
* script to delete. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
EventScriptRecord *esPtr, *prevEsPtr;
for (esPtr = statePtr->scriptRecordPtr, prevEsPtr = NULL; esPtr != NULL;
@@ -7730,7 +7760,8 @@ CreateScriptRecord(
* invoked. */
Tcl_Obj *scriptPtr) /* Pointer to script object. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
EventScriptRecord *esPtr;
for (esPtr=statePtr->scriptRecordPtr; esPtr!=NULL; esPtr=esPtr->nextPtr) {
@@ -7844,7 +7875,7 @@ Tcl_FileEventObjCmd(
Tcl_Obj *CONST objv[]) /* Argument objects. */
{
Channel *chanPtr; /* The channel to create the handler for. */
- ChannelState *statePtr; /* state info for channel */
+ ChannelState *statePtr; /* State info for channel */
Tcl_Channel chan; /* The opaque type for the channel. */
char *chanName;
int modeIndex; /* Index of mode argument. */
@@ -7862,7 +7893,7 @@ Tcl_FileEventObjCmd(
}
mask = maskArray[modeIndex];
- chanName = Tcl_GetString(objv[1]);
+ chanName = TclGetString(objv[1]);
chan = Tcl_GetChannel(interp, chanName, NULL);
if (chan == (Tcl_Channel) NULL) {
return TCL_ERROR;
@@ -7895,7 +7926,7 @@ Tcl_FileEventObjCmd(
* If we are supposed to delete a stored script, do so.
*/
- if (*(Tcl_GetString(objv[3])) == '\0') {
+ if (*(TclGetString(objv[3])) == '\0') {
DeleteScriptRecord(interp, chanPtr, mask);
return TCL_OK;
}
@@ -8048,15 +8079,14 @@ CopyData(
int mask) /* Current channel event flags. */
{
Tcl_Interp *interp;
- Tcl_Obj *cmdPtr, *errObj = NULL, *bufObj = NULL;
- Tcl_Obj* msg = NULL;
+ Tcl_Obj *cmdPtr, *errObj = NULL, *bufObj = NULL, *msg = NULL;
Tcl_Channel inChan, outChan;
ChannelState *inStatePtr, *outStatePtr;
int result = TCL_OK, size, total, sizeb;
char *buffer;
-
- int inBinary, outBinary, sameEncoding; /* Encoding control */
- int underflow; /* input underflow */
+ int inBinary, outBinary, sameEncoding;
+ /* Encoding control */
+ int underflow; /* Input underflow */
inChan = (Tcl_Channel) csPtr->readPtr;
outChan = (Tcl_Channel) csPtr->writePtr;
@@ -8113,9 +8143,10 @@ CopyData(
if (inBinary || sameEncoding) {
size = DoRead(inStatePtr->topChanPtr, csPtr->buffer, sizeb);
} else {
- size = DoReadChars(inStatePtr->topChanPtr, bufObj, sizeb, 0 /* No append */);
+ size = DoReadChars(inStatePtr->topChanPtr, bufObj, sizeb,
+ 0 /* No append */);
}
- underflow = (size >= 0) && (size < sizeb); /* input underflow */
+ underflow = (size >= 0) && (size < sizeb); /* Input underflow */
if (size < 0) {
readError:
@@ -8173,9 +8204,13 @@ CopyData(
}
if (inBinary || sameEncoding) {
- /* Both read and write counted bytes */
+ /*
+ * Both read and write counted bytes.
+ */
+
size = sizeb;
- } /* else : Read counted characters, write counted bytes, i.e. size != sizeb */
+ } /* else: Read counted characters, write counted bytes, i.e.
+ * size != sizeb */
if (sizeb < 0) {
writeError:
@@ -8329,7 +8364,8 @@ DoRead(
char *bufPtr, /* Where to store input read. */
int toRead) /* Maximum number of bytes to read. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
int copied; /* How many characters were copied into the
* result string? */
int copiedNow; /* How many characters were copied from the
@@ -8358,7 +8394,7 @@ DoRead(
if (statePtr->flags & CHANNEL_NONBLOCKING) {
goto done;
}
- statePtr->flags &= (~(CHANNEL_BLOCKED));
+ statePtr->flags &= ~CHANNEL_BLOCKED;
}
result = GetInput(chanPtr);
if (result != 0) {
@@ -8370,7 +8406,7 @@ DoRead(
}
}
- statePtr->flags &= (~(CHANNEL_BLOCKED));
+ statePtr->flags &= ~CHANNEL_BLOCKED;
/*
* Update the notifier state so we don't block while there is still data
@@ -8443,8 +8479,7 @@ CopyAndTranslateBuffer(
if (bytesInBuffer < space) {
space = bytesInBuffer;
}
- memcpy((VOID *) result, (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
- (size_t) space);
+ memcpy(result, bufPtr->buf + bufPtr->nextRemoved, (size_t) space);
bufPtr->nextRemoved += space;
copied = space;
break;
@@ -8463,8 +8498,7 @@ CopyAndTranslateBuffer(
if (bytesInBuffer < space) {
space = bytesInBuffer;
}
- memcpy((VOID *) result, (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
- (size_t) space);
+ memcpy(result, bufPtr->buf + bufPtr->nextRemoved, (size_t) space);
bufPtr->nextRemoved += space;
copied = space;
@@ -8494,15 +8528,14 @@ CopyAndTranslateBuffer(
}
/*
- * Copy the current chunk and replace "\r\n" with "\n"
- * (but not standalone "\r"!).
+ * Copy the current chunk and replace "\r\n" with "\n" (but not
+ * standalone "\r"!).
*/
if (bytesInBuffer < space) {
space = bytesInBuffer;
}
- memcpy((VOID *) result, (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
- (size_t) space);
+ memcpy(result, bufPtr->buf + bufPtr->nextRemoved, (size_t) space);
bufPtr->nextRemoved += space;
copied = space;
@@ -8542,8 +8575,7 @@ CopyAndTranslateBuffer(
if (bytesInBuffer < space) {
space = bytesInBuffer;
}
- memcpy((VOID *) result, (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
- (size_t) space);
+ memcpy(result, bufPtr->buf + bufPtr->nextRemoved, (size_t) space);
bufPtr->nextRemoved += space;
copied = space;
@@ -8584,7 +8616,7 @@ CopyAndTranslateBuffer(
* caller.
*/
- statePtr->flags |= (CHANNEL_EOF | CHANNEL_STICKY_EOF);
+ statePtr->flags |= CHANNEL_EOF | CHANNEL_STICKY_EOF;
statePtr->inputEncodingFlags |= TCL_ENCODING_END;
copied = i;
break;
@@ -8674,8 +8706,7 @@ CopyBuffer(
space = bytesInBuffer;
}
- memcpy((VOID *) result, (VOID *) (bufPtr->buf + bufPtr->nextRemoved),
- (size_t) space);
+ memcpy(result, bufPtr->buf + bufPtr->nextRemoved, (size_t) space);
bufPtr->nextRemoved += space;
copied = space;
@@ -8731,7 +8762,8 @@ DoWrite(
CONST char *src, /* Data to write. */
int srcLen) /* Number of bytes to write. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
ChannelBuffer *outBufPtr; /* Current output buffer. */
int foundNewline; /* Did we find a newline in output? */
char *dPtr;
@@ -8783,11 +8815,11 @@ DoWrite(
switch (statePtr->outputTranslation) {
case TCL_TRANSLATE_LF:
srcCopied = destCopied;
- memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
+ memcpy(destPtr, src, (size_t) destCopied);
break;
case TCL_TRANSLATE_CR:
srcCopied = destCopied;
- memcpy((VOID *) destPtr, (VOID *) src, (size_t) destCopied);
+ memcpy(destPtr, src, (size_t) destCopied);
for (dPtr = destPtr; dPtr < destPtr + destCopied; dPtr++) {
if (*dPtr == '\n') {
*dPtr = '\r';
@@ -9021,8 +9053,9 @@ SetBlockMode(
int mode) /* One of TCL_MODE_BLOCKING or
* TCL_MODE_NONBLOCKING. */
{
- ChannelState *statePtr = chanPtr->state; /* state info for channel */
int result = 0;
+ ChannelState *statePtr = chanPtr->state;
+ /* State info for channel */
result = StackSetBlockMode(chanPtr, mode);
if (result != 0) {
@@ -9055,7 +9088,7 @@ SetBlockMode(
return TCL_ERROR;
}
if (mode == TCL_MODE_BLOCKING) {
- statePtr->flags &= (~(CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED));
+ statePtr->flags &= ~(CHANNEL_NONBLOCKING | BG_FLUSH_SCHEDULED);
} else {
statePtr->flags |= CHANNEL_NONBLOCKING;
}
@@ -9110,8 +9143,8 @@ Tcl_GetChannelNamesEx(
{
ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
ChannelState *statePtr;
- CONST char *name; /* name for channel */
- Tcl_Obj *resultPtr; /* pointer to result object */
+ CONST char *name; /* Name for channel */
+ Tcl_Obj *resultPtr; /* Pointer to result object */
Tcl_HashTable *hTblPtr; /* Hash table of channels. */
Tcl_HashEntry *hPtr; /* Search variable. */
Tcl_HashSearch hSearch; /* Search variable. */
@@ -9205,7 +9238,7 @@ Tcl_IsChannelRegistered(
chanPtr = ((Channel *) chan)->state->bottomChanPtr;
statePtr = chanPtr->state;
- hTblPtr = (Tcl_HashTable *) Tcl_GetAssocData(interp, "tclIO", NULL);
+ hTblPtr = Tcl_GetAssocData(interp, "tclIO", NULL);
if (hTblPtr == NULL) {
return 0;
}
@@ -9336,7 +9369,8 @@ Tcl_ChannelName(
Tcl_ChannelTypeVersion
Tcl_ChannelVersion(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
if (chanTypePtr->version == TCL_CHANNEL_VERSION_2) {
return TCL_CHANNEL_VERSION_2;
@@ -9400,7 +9434,8 @@ HaveVersion(
Tcl_DriverBlockModeProc *
Tcl_ChannelBlockModeProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
return chanTypePtr->blockModeProc;
@@ -9431,7 +9466,8 @@ Tcl_ChannelBlockModeProc(
Tcl_DriverCloseProc *
Tcl_ChannelCloseProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->closeProc;
}
@@ -9454,7 +9490,8 @@ Tcl_ChannelCloseProc(
Tcl_DriverClose2Proc *
Tcl_ChannelClose2Proc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->close2Proc;
}
@@ -9477,7 +9514,8 @@ Tcl_ChannelClose2Proc(
Tcl_DriverInputProc *
Tcl_ChannelInputProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->inputProc;
}
@@ -9500,7 +9538,8 @@ Tcl_ChannelInputProc(
Tcl_DriverOutputProc *
Tcl_ChannelOutputProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->outputProc;
}
@@ -9523,7 +9562,8 @@ Tcl_ChannelOutputProc(
Tcl_DriverSeekProc *
Tcl_ChannelSeekProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->seekProc;
}
@@ -9546,7 +9586,8 @@ Tcl_ChannelSeekProc(
Tcl_DriverSetOptionProc *
Tcl_ChannelSetOptionProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->setOptionProc;
}
@@ -9569,7 +9610,8 @@ Tcl_ChannelSetOptionProc(
Tcl_DriverGetOptionProc *
Tcl_ChannelGetOptionProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->getOptionProc;
}
@@ -9592,7 +9634,8 @@ Tcl_ChannelGetOptionProc(
Tcl_DriverWatchProc *
Tcl_ChannelWatchProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->watchProc;
}
@@ -9615,7 +9658,8 @@ Tcl_ChannelWatchProc(
Tcl_DriverGetHandleProc *
Tcl_ChannelGetHandleProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
return chanTypePtr->getHandleProc;
}
@@ -9638,7 +9682,8 @@ Tcl_ChannelGetHandleProc(
Tcl_DriverFlushProc *
Tcl_ChannelFlushProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
return chanTypePtr->flushProc;
@@ -9665,7 +9710,8 @@ Tcl_ChannelFlushProc(
Tcl_DriverHandlerProc *
Tcl_ChannelHandlerProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_2)) {
return chanTypePtr->handlerProc;
@@ -9692,7 +9738,8 @@ Tcl_ChannelHandlerProc(
Tcl_DriverWideSeekProc *
Tcl_ChannelWideSeekProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_3)) {
return chanTypePtr->wideSeekProc;
@@ -9720,7 +9767,8 @@ Tcl_ChannelWideSeekProc(
Tcl_DriverThreadActionProc *
Tcl_ChannelThreadActionProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_4)) {
return chanTypePtr->threadActionProc;
@@ -9754,7 +9802,7 @@ Tcl_SetChannelErrorInterp(
Interp *iPtr = (Interp *) interp;
if (iPtr->chanMsg != NULL) {
- Tcl_DecrRefCount(iPtr->chanMsg);
+ TclDecrRefCount(iPtr->chanMsg);
iPtr->chanMsg = NULL;
}
@@ -9787,10 +9835,10 @@ Tcl_SetChannelError(
Tcl_Channel chan, /* Channel to store the data into. */
Tcl_Obj *msg) /* Error message to store. */
{
- ChannelState* statePtr = ((Channel*) chan)->state;
+ ChannelState *statePtr = ((Channel *) chan)->state;
if (statePtr->chanMsg != NULL) {
- Tcl_DecrRefCount(statePtr->chanMsg);
+ TclDecrRefCount(statePtr->chanMsg);
statePtr->chanMsg = NULL;
}
@@ -9824,15 +9872,10 @@ static Tcl_Obj *
FixLevelCode(
Tcl_Obj *msg)
{
- int lc;
- Tcl_Obj **lv;
- int explicitResult;
- int numOptions;
- int lcn;
- Tcl_Obj **lvn;
+ int explicitResult, numOptions, lc, lcn;
+ Tcl_Obj **lv, **lvn;
int res, i, j, val, lignore, cignore;
- Tcl_Obj *newlevel = NULL;
- Tcl_Obj *newcode = NULL;
+ Tcl_Obj *newlevel = NULL, *newcode = NULL;
/* ASSERT msg != NULL */
@@ -9841,9 +9884,9 @@ FixLevelCode(
*
* Syntax = (option value)... ?message?
*
- * Bad syntax causes a panic. Because the other side uses
+ * Bad message syntax causes a panic, because the other side uses
* Tcl_GetReturnOptions and list construction functions to marshall the
- * information.
+ * information. Hence an error means that we've got serious breakage.
*/
res = Tcl_ListObjGetElements(NULL, msg, &lc, &lv);
@@ -10034,7 +10077,8 @@ Tcl_GetChannelError(
Tcl_DriverTruncateProc *
Tcl_ChannelTruncateProc(
- Tcl_ChannelType *chanTypePtr) /* Pointer to channel type. */
+ Tcl_ChannelType *chanTypePtr)
+ /* Pointer to channel type. */
{
if (HaveVersion(chanTypePtr, TCL_CHANNEL_VERSION_5)) {
return chanTypePtr->truncateProc;
diff --git a/generic/tclPkg.c b/generic/tclPkg.c
index 0814677..7e148d1 100644
--- a/generic/tclPkg.c
+++ b/generic/tclPkg.c
@@ -10,7 +10,7 @@
* See the file "license.terms" for information on usage and redistribution of
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tclPkg.c,v 1.23 2006/11/02 15:58:08 dgp Exp $
+ * RCS: @(#) $Id: tclPkg.c,v 1.24 2006/11/08 11:41:44 dkf Exp $
*
* TIP #268.
* Heavily rewritten to handle the extend version numbers, and extended
@@ -55,25 +55,37 @@ typedef struct Package {
* Prototypes for functions defined in this file:
*/
-static int CheckVersionAndConvert(Tcl_Interp *interp, CONST char *string,
- char** internal, int* stable);
-
+static int CheckVersionAndConvert(Tcl_Interp *interp,
+ CONST char *string, char **internal, int *stable);
static int CompareVersions(char *v1i, char *v2i,
- int *isMajorPtr);
-static int CheckRequirement(Tcl_Interp *interp, CONST char *string);
-static int CheckAllRequirements(Tcl_Interp* interp,
- int reqc, Tcl_Obj *CONST reqv[]);
+ int *isMajorPtr);
+static int CheckRequirement(Tcl_Interp *interp,
+ CONST char *string);
+static int CheckAllRequirements(Tcl_Interp *interp, int reqc,
+ Tcl_Obj *CONST reqv[]);
static int RequirementSatisfied(char *havei, CONST char *req);
-static int AllRequirementsSatisfied(char *havei,
- int reqc, Tcl_Obj *CONST reqv[]);
-static void AddRequirementsToResult(Tcl_Interp* interp,
- int reqc, Tcl_Obj *CONST reqv[]);
-static void AddRequirementsToDString(Tcl_DString* dstring,
- int reqc, Tcl_Obj *CONST reqv[]);
+static int AllRequirementsSatisfied(char *havei, int reqc,
+ Tcl_Obj *CONST reqv[]);
+static void AddRequirementsToResult(Tcl_Interp *interp, int reqc,
+ Tcl_Obj *CONST reqv[]);
+static void AddRequirementsToDString(Tcl_DString *dstring,
+ int reqc, Tcl_Obj *CONST reqv[]);
static Package * FindPackage(Tcl_Interp *interp, CONST char *name);
-static Tcl_Obj* ExactRequirement(CONST char* version);
+static Tcl_Obj * ExactRequirement(CONST char *version);
static void VersionCleanupProc(ClientData clientData,
Tcl_Interp *interp);
+
+/*
+ * Helper macros.
+ */
+
+#define DupBlock(v,s,len) \
+ ((v) = ckalloc(len), memcpy((v),(s),(len)))
+#define DupString(v,s) \
+ do { \
+ unsigned local__len = (unsigned) (strlen(s) + 1); \
+ DupBlock((v),(s),local__len); \
+ } while (0)
/*
*----------------------------------------------------------------------
@@ -103,7 +115,7 @@ Tcl_PkgProvide(
CONST char *name, /* Name of package. */
CONST char *version) /* Version string for package. */
{
- return Tcl_PkgProvideEx(interp, name, version, (ClientData) NULL);
+ return Tcl_PkgProvideEx(interp, name, version, NULL);
}
int
@@ -116,28 +128,27 @@ Tcl_PkgProvideEx(
* for C callback function table) */
{
Package *pkgPtr;
- char* pvi;
- char* vi;
+ char *pvi, *vi;
int res;
pkgPtr = FindPackage(interp, name);
if (pkgPtr->version == NULL) {
- pkgPtr->version = ckalloc((unsigned) (strlen(version) + 1));
- strcpy(pkgPtr->version, version);
+ DupString(pkgPtr->version, version);
pkgPtr->clientData = clientData;
return TCL_OK;
}
- if (CheckVersionAndConvert (interp, pkgPtr->version, &pvi, NULL) != TCL_OK) {
+ if (CheckVersionAndConvert(interp, pkgPtr->version, &pvi,
+ NULL) != TCL_OK) {
return TCL_ERROR;
- } else if (CheckVersionAndConvert (interp, version, &vi, NULL) != TCL_OK) {
- Tcl_Free (pvi);
+ } else if (CheckVersionAndConvert(interp, version, &vi, NULL) != TCL_OK) {
+ ckfree(pvi);
return TCL_ERROR;
}
res = CompareVersions(pvi, vi, NULL);
- Tcl_Free (pvi);
- Tcl_Free (vi);
+ ckfree(pvi);
+ ckfree(vi);
if (res == 0) {
if (clientData != NULL) {
@@ -286,21 +297,22 @@ Tcl_PkgRequireEx(
res = Tcl_PkgRequireProc(interp, name, 0, NULL, clientDataPtr);
} else {
if (exact) {
- ov = ExactRequirement (version);
+ ov = ExactRequirement(version);
} else {
- ov = Tcl_NewStringObj (version,-1);
+ ov = Tcl_NewStringObj(version, -1);
}
- Tcl_IncrRefCount (ov);
+ Tcl_IncrRefCount(ov);
res = Tcl_PkgRequireProc(interp, name, 1, &ov, clientDataPtr);
- Tcl_DecrRefCount (ov);
+ TclDecrRefCount(ov);
}
if (res != TCL_OK) {
return NULL;
}
- /* This function returns the version string explictly, and leaves the
+ /*
+ * This function returns the version string explictly, and leaves the
* interpreter result empty. However "Tcl_PkgRequireProc" above returned
* the version through the interpreter result. Simply resetting the result
* now potentially deletes the string (obj), and the pointer to its string
@@ -310,22 +322,21 @@ Tcl_PkgRequireEx(
* dangle. It will be a leak however if nothing is done. So the next time
* we come through here we delete the object remembered by this call, as
* we can then be sure that there is no pointer to its string around
- * anymore. Beyond that we have a deletion function which cleans up the last
- * remembered object which was not cleaned up directly, here.
+ * anymore. Beyond that we have a deletion function which cleans up the
+ * last remembered object which was not cleaned up directly, here.
*/
- ov = (Tcl_Obj*) Tcl_GetAssocData (interp, "tcl/Tcl_PkgRequireEx", NULL);
+ ov = (Tcl_Obj *) Tcl_GetAssocData(interp, "tcl/Tcl_PkgRequireEx", NULL);
if (ov != NULL) {
- Tcl_DecrRefCount (ov);
+ TclDecrRefCount(ov);
}
- ov = Tcl_GetObjResult (interp);
- Tcl_IncrRefCount (ov);
- Tcl_SetAssocData(interp, "tcl/Tcl_PkgRequireEx", VersionCleanupProc,
- (ClientData) ov);
- Tcl_ResetResult (interp);
+ ov = Tcl_GetObjResult(interp);
+ Tcl_IncrRefCount(ov);
+ Tcl_SetAssocData(interp, "tcl/Tcl_PkgRequireEx", VersionCleanupProc, ov);
+ Tcl_ResetResult(interp);
- return Tcl_GetString (ov);
+ return TclGetString(ov);
}
int
@@ -333,19 +344,22 @@ Tcl_PkgRequireProc(
Tcl_Interp *interp, /* Interpreter in which package is now
* available. */
CONST char *name, /* Name of desired package. */
- int reqc, /* Requirements constraining the desired version. */
- Tcl_Obj *CONST reqv[], /* 0 means to use the latest version available. */
+ int reqc, /* Requirements constraining the desired
+ * version. */
+ Tcl_Obj *CONST reqv[], /* 0 means to use the latest version
+ * available. */
ClientData *clientDataPtr)
{
Interp *iPtr = (Interp *) interp;
Package *pkgPtr;
- PkgAvail *availPtr, *bestPtr, *bestStablePtr;
- char *availVersion, *bestVersion; /* Internal rep. of versions */
- int availStable;
+ PkgAvail *availPtr, *bestPtr, *bestStablePtr;
+ char *availVersion, *bestVersion;
+ /* Internal rep. of versions */
+ int availStable;
char *script;
int code, satisfies, pass;
Tcl_DString command;
- char* pkgVersionI;
+ char *pkgVersionI;
/*
* It can take up to three passes to find the package: one pass to run the
@@ -354,7 +368,7 @@ Tcl_PkgRequireProc(
* the "package ifneeded" script.
*/
- for (pass = 1; ; pass++) {
+ for (pass=1 ;; pass++) {
pkgPtr = FindPackage(interp, name);
if (pkgPtr->version != NULL) {
break;
@@ -368,28 +382,28 @@ Tcl_PkgRequireProc(
if (pkgPtr->clientData != NULL) {
Tcl_AppendResult(interp, "circular package dependency: ",
"attempt to provide ", name, " ",
- (char *)(pkgPtr->clientData), " requires ", name, NULL);
- AddRequirementsToResult (interp, reqc, reqv);
+ (char *) pkgPtr->clientData, " requires ", name, NULL);
+ AddRequirementsToResult(interp, reqc, reqv);
return TCL_ERROR;
}
/*
* The package isn't yet present. Search the list of available
- * versions and invoke the script for the best available version.
- * We are actually locating the best, and the best stable version.
- * One of them is then chosen based on the selection mode.
+ * versions and invoke the script for the best available version. We
+ * are actually locating the best, and the best stable version. One of
+ * them is then chosen based on the selection mode.
*/
- bestPtr = NULL;
- bestStablePtr = NULL;
- bestVersion = NULL;
+ bestPtr = NULL;
+ bestStablePtr = NULL;
+ bestVersion = NULL;
- for (availPtr = pkgPtr->availPtr;
- availPtr != NULL;
- availPtr = availPtr->nextPtr) {
- if (CheckVersionAndConvert (interp, availPtr->version,
- &availVersion, &availStable) != TCL_OK) {
- /* The provided version number is has invalid syntax. This
+ for (availPtr = pkgPtr->availPtr; availPtr != NULL;
+ availPtr = availPtr->nextPtr) {
+ if (CheckVersionAndConvert(interp, availPtr->version,
+ &availVersion, &availStable) != TCL_OK) {
+ /*
+ * The provided version number is has invalid syntax. This
* should not happen. This should have been caught by the
* 'package ifneeded' registering the package.
*/
@@ -398,24 +412,33 @@ Tcl_PkgRequireProc(
}
if (bestPtr != NULL) {
- int res = CompareVersions (availVersion, bestVersion, NULL);
+ int res = CompareVersions(availVersion, bestVersion, NULL);
+
/* Note: Use internal reps! */
if (res <= 0) {
- /* The version of the package sought is not as good as the
- * currently selected version. Ignore it. */
- Tcl_Free (availVersion);
+ /*
+ * The version of the package sought is not as good as the
+ * currently selected version. Ignore it.
+ */
+
+ ckfree(availVersion);
availVersion = NULL;
continue;
}
}
- /* We have found a version which is better than our max. */
+ /*
+ * We have found a version which is better than our max.
+ */
if (reqc > 0) {
- /* Check satisfaction of requirements */
- satisfies = AllRequirementsSatisfied (availVersion, reqc, reqv);
+ /*
+ * Check satisfaction of requirements.
+ */
+
+ satisfies = AllRequirementsSatisfied(availVersion,reqc,reqv);
if (!satisfies) {
- Tcl_Free (availVersion);
+ ckfree(availVersion);
availVersion = NULL;
continue;
}
@@ -423,10 +446,13 @@ Tcl_PkgRequireProc(
bestPtr = availPtr;
- if (bestVersion != NULL) Tcl_Free (bestVersion);
+ if (bestVersion != NULL) {
+ ckfree(bestVersion);
+ }
bestVersion = availVersion;
- /* If this new best version is stable then it also has to be
+ /*
+ * If this new best version is stable then it also has to be
* better than the max stable version found so far.
*/
@@ -436,15 +462,17 @@ Tcl_PkgRequireProc(
}
if (bestVersion != NULL) {
- Tcl_Free (bestVersion);
+ ckfree(bestVersion);
}
- /* Now choose a version among the two best. For 'latest' we simply
+ /*
+ * Now choose a version among the two best. For 'latest' we simply
* take (actually keep) the best. For 'stable' we take the best
* stable, if there is any, or the best if there is nothing stable.
*/
- if ((iPtr->packagePrefer == PKG_PREFER_STABLE) && (bestStablePtr != NULL)) {
+ if ((iPtr->packagePrefer == PKG_PREFER_STABLE)
+ && (bestStablePtr != NULL)) {
bestPtr = bestStablePtr;
}
@@ -455,6 +483,7 @@ Tcl_PkgRequireProc(
* script itself from deletion and (b) don't assume that bestPtr
* will still exist when the script completes.
*/
+
CONST char *versionToProvide = bestPtr->version;
script = bestPtr->script;
@@ -474,26 +503,28 @@ Tcl_PkgRequireProc(
" failed: no version of package ", name,
" provided", NULL);
} else {
- char* pvi;
- char* vi;
+ char *pvi, *vi;
int res;
- if (CheckVersionAndConvert (interp, pkgPtr->version, &pvi, NULL) != TCL_OK) {
+ if (CheckVersionAndConvert(interp, pkgPtr->version, &pvi,
+ NULL) != TCL_OK) {
code = TCL_ERROR;
- } else if (CheckVersionAndConvert (interp, versionToProvide, &vi, NULL) != TCL_OK) {
- Tcl_Free (pvi);
+ } else if (CheckVersionAndConvert(interp,
+ versionToProvide, &vi, NULL) != TCL_OK) {
+ ckfree(pvi);
code = TCL_ERROR;
} else {
res = CompareVersions(pvi, vi, NULL);
- Tcl_Free (pvi);
- Tcl_Free (vi);
+ ckfree(pvi);
+ ckfree(vi);
if (res != 0) {
code = TCL_ERROR;
- Tcl_AppendResult(interp, "attempt to provide package ",
- name, " ", versionToProvide, " failed: package ",
- name, " ", pkgPtr->version, " provided instead",
- NULL);
+ Tcl_AppendResult(interp,
+ "attempt to provide package ", name, " ",
+ versionToProvide, " failed: package ",
+ name, " ", pkgPtr->version,
+ " provided instead", NULL);
}
}
}
@@ -502,8 +533,8 @@ Tcl_PkgRequireProc(
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "attempt to provide package ",
name, " ", versionToProvide, " failed: ",
- "bad return code: ", Tcl_GetString(codePtr), NULL);
- Tcl_DecrRefCount(codePtr);
+ "bad return code: ", TclGetString(codePtr), NULL);
+ TclDecrRefCount(codePtr);
code = TCL_ERROR;
}
@@ -516,16 +547,16 @@ Tcl_PkgRequireProc(
if (code != TCL_OK) {
/*
- * Take a non-TCL_OK code from the script as an
- * indication the package wasn't loaded properly,
- * so the package system should not remember an
- * improper load.
+ * Take a non-TCL_OK code from the script as an indication the
+ * package wasn't loaded properly, so the package system
+ * should not remember an improper load.
*
- * This is consistent with our returning NULL.
- * If we're not willing to tell our caller we
- * got a particular version, we shouldn't store
- * that version for telling future callers either.
+ * This is consistent with our returning NULL. If we're not
+ * willing to tell our caller we got a particular version, we
+ * shouldn't store that version for telling future callers
+ * either.
*/
+
if (pkgPtr->version != NULL) {
ckfree(pkgPtr->version);
pkgPtr->version = NULL;
@@ -562,12 +593,13 @@ Tcl_PkgRequireProc(
Tcl_Obj *codePtr = Tcl_NewIntObj(code);
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "bad return code: ",
- Tcl_GetString(codePtr), NULL);
+ TclGetString(codePtr), NULL);
Tcl_DecrRefCount(codePtr);
code = TCL_ERROR;
}
if (code == TCL_ERROR) {
- Tcl_AddErrorInfo(interp, "\n (\"package unknown\" script)");
+ Tcl_AddErrorInfo(interp,
+ "\n (\"package unknown\" script)");
return TCL_ERROR;
}
Tcl_ResetResult(interp);
@@ -588,23 +620,23 @@ Tcl_PkgRequireProc(
if (reqc == 0) {
satisfies = 1;
} else {
- CheckVersionAndConvert (interp, pkgPtr->version, &pkgVersionI, NULL);
- satisfies = AllRequirementsSatisfied (pkgVersionI, reqc, reqv);
+ CheckVersionAndConvert(interp, pkgPtr->version, &pkgVersionI, NULL);
+ satisfies = AllRequirementsSatisfied(pkgVersionI, reqc, reqv);
- Tcl_Free (pkgVersionI);
+ ckfree(pkgVersionI);
}
if (satisfies) {
if (clientDataPtr) {
*clientDataPtr = pkgPtr->clientData;
}
- Tcl_SetObjResult (interp, Tcl_NewStringObj (pkgPtr->version, -1));
+ Tcl_SetObjResult(interp, Tcl_NewStringObj(pkgPtr->version, -1));
return TCL_OK;
}
- Tcl_AppendResult(interp, "version conflict for package \"",
- name, "\": have ", pkgPtr->version, ", need", NULL);
- AddRequirementsToResult (interp, reqc, reqv);
+ Tcl_AppendResult(interp, "version conflict for package \"", name,
+ "\": have ", pkgPtr->version, ", need", NULL);
+ AddRequirementsToResult(interp, reqc, reqv);
return TCL_ERROR;
}
@@ -665,10 +697,9 @@ Tcl_PkgPresentEx(
hPtr = Tcl_FindHashEntry(&iPtr->packageTable, name);
if (hPtr) {
- pkgPtr = (Package *) Tcl_GetHashValue(hPtr);
+ pkgPtr = Tcl_GetHashValue(hPtr);
if (pkgPtr->version != NULL) {
- char* pvi;
- char* vi;
+ char *pvi, *vi;
int thisIsMajor;
/*
@@ -684,16 +715,18 @@ Tcl_PkgPresentEx(
return pkgPtr->version;
}
- if (CheckVersionAndConvert (interp, pkgPtr->version, &pvi, NULL) != TCL_OK) {
+ if (CheckVersionAndConvert(interp, pkgPtr->version, &pvi,
+ NULL) != TCL_OK) {
return NULL;
- } else if (CheckVersionAndConvert (interp, version, &vi, NULL) != TCL_OK) {
- Tcl_Free (pvi);
+ } else if (CheckVersionAndConvert(interp, version, &vi,
+ NULL) != TCL_OK) {
+ ckfree(pvi);
return NULL;
}
result = CompareVersions(pvi, vi, &thisIsMajor);
- Tcl_Free (pvi);
- Tcl_Free (vi);
+ ckfree(pvi);
+ ckfree(vi);
satisfies = (result == 0) || ((result == 1) && !thisIsMajor);
@@ -762,9 +795,7 @@ Tcl_PackageObjCmd(
Tcl_HashSearch search;
Tcl_HashTable *tablePtr;
CONST char *version;
- char *argv2, *argv3, *argv4;
- char* iva = NULL;
- char* ivb = NULL;
+ char *argv2, *argv3, *argv4, *iva = NULL, *ivb = NULL;
if (objc < 2) {
Tcl_WrongNumArgs(interp, 1, objv, "option ?arg arg ...?");
@@ -780,12 +811,12 @@ Tcl_PackageObjCmd(
char *keyString;
for (i = 2; i < objc; i++) {
- keyString = Tcl_GetString(objv[i]);
+ keyString = TclGetString(objv[i]);
hPtr = Tcl_FindHashEntry(&iPtr->packageTable, keyString);
if (hPtr == NULL) {
continue;
}
- pkgPtr = (Package *) Tcl_GetHashValue(hPtr);
+ pkgPtr = Tcl_GetHashValue(hPtr);
Tcl_DeleteHashEntry(hPtr);
if (pkgPtr->version != NULL) {
ckfree(pkgPtr->version);
@@ -802,47 +833,45 @@ Tcl_PackageObjCmd(
break;
}
case PKG_IFNEEDED: {
- int length;
- char* argv3i;
- char* avi;
- int res;
+ int length, res;
+ char *argv3i, *avi;
if ((objc != 4) && (objc != 5)) {
Tcl_WrongNumArgs(interp, 2, objv, "package version ?script?");
return TCL_ERROR;
}
- argv3 = Tcl_GetString(objv[3]);
+ argv3 = TclGetString(objv[3]);
if (CheckVersionAndConvert(interp, argv3, &argv3i, NULL) != TCL_OK) {
return TCL_ERROR;
}
- argv2 = Tcl_GetString(objv[2]);
+ argv2 = TclGetString(objv[2]);
if (objc == 4) {
hPtr = Tcl_FindHashEntry(&iPtr->packageTable, argv2);
if (hPtr == NULL) {
- Tcl_Free (argv3i);
+ ckfree(argv3i);
return TCL_OK;
}
- pkgPtr = (Package *) Tcl_GetHashValue(hPtr);
+ pkgPtr = Tcl_GetHashValue(hPtr);
} else {
pkgPtr = FindPackage(interp, argv2);
}
argv3 = Tcl_GetStringFromObj(objv[3], &length);
- for (availPtr = pkgPtr->availPtr, prevPtr = NULL;
- availPtr != NULL;
- prevPtr = availPtr, availPtr = availPtr->nextPtr) {
+ for (availPtr = pkgPtr->availPtr, prevPtr = NULL; availPtr != NULL;
+ prevPtr = availPtr, availPtr = availPtr->nextPtr) {
- if (CheckVersionAndConvert (interp, availPtr->version, &avi, NULL) != TCL_OK) {
- Tcl_Free (argv3i);
+ if (CheckVersionAndConvert(interp, availPtr->version, &avi,
+ NULL) != TCL_OK) {
+ ckfree(argv3i);
return TCL_ERROR;
}
res = CompareVersions(avi, argv3i, NULL);
- Tcl_Free (avi);
+ ckfree(avi);
if (res == 0){
if (objc == 4) {
- Tcl_Free (argv3i);
+ ckfree(argv3i);
Tcl_SetResult(interp, availPtr->script, TCL_VOLATILE);
return TCL_OK;
}
@@ -850,15 +879,14 @@ Tcl_PackageObjCmd(
break;
}
}
- Tcl_Free (argv3i);
+ ckfree(argv3i);
if (objc == 4) {
return TCL_OK;
}
if (availPtr == NULL) {
availPtr = (PkgAvail *) ckalloc(sizeof(PkgAvail));
- availPtr->version = ckalloc((unsigned) (length + 1));
- strcpy(availPtr->version, argv3);
+ DupBlock(availPtr->version, argv3, (unsigned) length + 1);
if (prevPtr == NULL) {
availPtr->nextPtr = pkgPtr->availPtr;
@@ -869,8 +897,7 @@ Tcl_PackageObjCmd(
}
}
argv4 = Tcl_GetStringFromObj(objv[4], &length);
- availPtr->script = ckalloc((unsigned) (length + 1));
- strcpy(availPtr->script, argv4);
+ DupBlock(availPtr->script, argv4, (unsigned) length + 1);
break;
}
case PKG_NAMES:
@@ -881,7 +908,7 @@ Tcl_PackageObjCmd(
tablePtr = &iPtr->packageTable;
for (hPtr = Tcl_FirstHashEntry(tablePtr, &search); hPtr != NULL;
hPtr = Tcl_NextHashEntry(&search)) {
- pkgPtr = (Package *) Tcl_GetHashValue(hPtr);
+ pkgPtr = Tcl_GetHashValue(hPtr);
if ((pkgPtr->version != NULL) || (pkgPtr->availPtr != NULL)) {
Tcl_AppendElement(interp, Tcl_GetHashKey(tablePtr, hPtr));
}
@@ -893,7 +920,7 @@ Tcl_PackageObjCmd(
Tcl_WrongNumArgs(interp, 2, objv, "?-exact? package ?version?");
return TCL_ERROR;
}
- argv2 = Tcl_GetString(objv[2]);
+ argv2 = TclGetString(objv[2]);
if ((argv2[0] == '-') && (strcmp(argv2, "-exact") == 0)) {
exact = 1;
} else {
@@ -901,15 +928,16 @@ Tcl_PackageObjCmd(
}
version = NULL;
if (objc == (4 + exact)) {
- version = Tcl_GetString(objv[3 + exact]);
- if (CheckVersionAndConvert(interp, version, NULL, NULL) != TCL_OK) {
+ version = TclGetString(objv[3 + exact]);
+ if (CheckVersionAndConvert(interp, version, NULL,
+ NULL) != TCL_OK) {
return TCL_ERROR;
}
} else if ((objc != 3) || exact) {
goto presentSyntax;
}
if (exact) {
- argv3 = Tcl_GetString(objv[3]);
+ argv3 = TclGetString(objv[3]);
version = Tcl_PkgPresent(interp, argv3, version, exact);
} else {
version = Tcl_PkgPresent(interp, argv2, version, exact);
@@ -917,25 +945,25 @@ Tcl_PackageObjCmd(
if (version == NULL) {
return TCL_ERROR;
}
- Tcl_SetObjResult( interp, Tcl_NewStringObj( version, -1 ) );
+ Tcl_SetObjResult(interp, Tcl_NewStringObj(version, -1));
break;
case PKG_PROVIDE:
if ((objc != 3) && (objc != 4)) {
Tcl_WrongNumArgs(interp, 2, objv, "package ?version?");
return TCL_ERROR;
}
- argv2 = Tcl_GetString(objv[2]);
+ argv2 = TclGetString(objv[2]);
if (objc == 3) {
hPtr = Tcl_FindHashEntry(&iPtr->packageTable, argv2);
if (hPtr != NULL) {
- pkgPtr = (Package *) Tcl_GetHashValue(hPtr);
+ pkgPtr = Tcl_GetHashValue(hPtr);
if (pkgPtr->version != NULL) {
Tcl_SetResult(interp, pkgPtr->version, TCL_VOLATILE);
}
}
return TCL_OK;
}
- argv3 = Tcl_GetString(objv[3]);
+ argv3 = TclGetString(objv[3]);
if (CheckVersionAndConvert(interp, argv3, NULL, NULL) != TCL_OK) {
return TCL_ERROR;
}
@@ -943,38 +971,42 @@ Tcl_PackageObjCmd(
case PKG_REQUIRE:
if (objc < 3) {
requireSyntax:
- Tcl_WrongNumArgs(interp, 2, objv, "?-exact? package ?requirement...?");
+ Tcl_WrongNumArgs(interp, 2, objv,
+ "?-exact? package ?requirement...?");
return TCL_ERROR;
}
version = NULL;
- argv2 = Tcl_GetString(objv[2]);
+ argv2 = TclGetString(objv[2]);
if ((argv2[0] == '-') && (strcmp(argv2, "-exact") == 0)) {
- Tcl_Obj* ov;
+ Tcl_Obj *ov;
int res;
if (objc != 5) {
goto requireSyntax;
}
- version = Tcl_GetString(objv[4]);
- if (CheckVersionAndConvert(interp, version, NULL, NULL) != TCL_OK) {
+ version = TclGetString(objv[4]);
+ if (CheckVersionAndConvert(interp, version, NULL,
+ NULL) != TCL_OK) {
return TCL_ERROR;
}
- /* Create a new-style requirement for the exact version. */
+ /*
+ * Create a new-style requirement for the exact version.
+ */
- ov = ExactRequirement (version);
+ ov = ExactRequirement(version);
version = NULL;
- argv3 = Tcl_GetString(objv[3]);
+ argv3 = TclGetString(objv[3]);
- Tcl_IncrRefCount (ov);
+ Tcl_IncrRefCount(ov);
res = Tcl_PkgRequireProc(interp, argv3, 1, &ov, NULL);
- Tcl_DecrRefCount (ov);
+ TclDecrRefCount(ov);
return res;
} else {
- if (CheckAllRequirements (interp, objc-3, objv+3) != TCL_OK) {
+ if (CheckAllRequirements(interp, objc-3, objv+3) != TCL_OK) {
return TCL_ERROR;
}
@@ -996,8 +1028,7 @@ Tcl_PackageObjCmd(
if (argv2[0] == 0) {
iPtr->packageUnknown = NULL;
} else {
- iPtr->packageUnknown = (char *) ckalloc((unsigned) (length+1));
- strcpy(iPtr->packageUnknown, argv2);
+ DupBlock(iPtr->packageUnknown, argv2, (unsigned) length+1);
}
} else {
Tcl_WrongNumArgs(interp, 2, objv, "?command?");
@@ -1006,31 +1037,40 @@ Tcl_PackageObjCmd(
break;
}
case PKG_PREFER: {
- /* See tclInt.h for the enum, just before Interp */
static CONST char *pkgPreferOptions[] = {
"latest", "stable", NULL
};
+ /*
+ * See tclInt.h for the enum, just before Interp.
+ */
+
if (objc > 3) {
Tcl_WrongNumArgs(interp, 2, objv, "?latest|stable?");
return TCL_ERROR;
- }
+ } else if (objc == 3) {
+ /*
+ * Seting the value.
+ */
- if (objc == 3) {
- /* Set value. */
+ int newPref;
- int new;
- if (Tcl_GetIndexFromObj(interp, objv[2], pkgPreferOptions, "preference", 0,
- &new) != TCL_OK) {
+ if (Tcl_GetIndexFromObj(interp, objv[2], pkgPreferOptions,
+ "preference", 0, &newPref) != TCL_OK) {
return TCL_ERROR;
}
- if (new < iPtr->packagePrefer) {
- iPtr->packagePrefer = new;
+ if (newPref < iPtr->packagePrefer) {
+ iPtr->packagePrefer = newPref;
}
}
- /* Always return current value. */
- Tcl_SetObjResult(interp, Tcl_NewStringObj (pkgPreferOptions [iPtr->packagePrefer], -1));
+
+ /*
+ * Always return current value.
+ */
+
+ Tcl_SetObjResult(interp,
+ Tcl_NewStringObj(pkgPreferOptions[iPtr->packagePrefer], -1));
break;
}
case PKG_VCOMPARE:
@@ -1038,29 +1078,39 @@ Tcl_PackageObjCmd(
Tcl_WrongNumArgs(interp, 2, objv, "version1 version2");
return TCL_ERROR;
}
- argv3 = Tcl_GetString(objv[3]);
- argv2 = Tcl_GetString(objv[2]);
- if ((CheckVersionAndConvert (interp, argv2, &iva, NULL) != TCL_OK) ||
- (CheckVersionAndConvert (interp, argv3, &ivb, NULL) != TCL_OK)) {
- if (iva != NULL) { Tcl_Free (iva); }
- /* ivb cannot be set in this branch */
+ argv3 = TclGetString(objv[3]);
+ argv2 = TclGetString(objv[2]);
+ if (CheckVersionAndConvert(interp, argv2, &iva, NULL) != TCL_OK ||
+ CheckVersionAndConvert(interp, argv3, &ivb, NULL) != TCL_OK) {
+ if (iva != NULL) {
+ ckfree(iva);
+ }
+
+ /*
+ * ivb cannot be set in this branch.
+ */
+
return TCL_ERROR;
}
- /* Comparison is done on the internal representation */
- Tcl_SetObjResult(interp,Tcl_NewIntObj(CompareVersions(iva, ivb, NULL)));
- Tcl_Free (iva);
- Tcl_Free (ivb);
+ /*
+ * Comparison is done on the internal representation.
+ */
+
+ Tcl_SetObjResult(interp,
+ Tcl_NewIntObj(CompareVersions(iva, ivb, NULL)));
+ ckfree(iva);
+ ckfree(ivb);
break;
case PKG_VERSIONS:
if (objc != 3) {
Tcl_WrongNumArgs(interp, 2, objv, "package");
return TCL_ERROR;
}
- argv2 = Tcl_GetString(objv[2]);
+ argv2 = TclGetString(objv[2]);
hPtr = Tcl_FindHashEntry(&iPtr->packageTable, argv2);
if (hPtr != NULL) {
- pkgPtr = (Package *) Tcl_GetHashValue(hPtr);
+ pkgPtr = Tcl_GetHashValue(hPtr);
for (availPtr = pkgPtr->availPtr; availPtr != NULL;
availPtr = availPtr->nextPtr) {
Tcl_AppendElement(interp, availPtr->version);
@@ -1068,23 +1118,24 @@ Tcl_PackageObjCmd(
}
break;
case PKG_VSATISFIES: {
- char* argv2i = NULL;
+ char *argv2i = NULL;
if (objc < 4) {
- Tcl_WrongNumArgs(interp, 2, objv, "version requirement requirement...");
+ Tcl_WrongNumArgs(interp, 2, objv,
+ "version requirement requirement...");
return TCL_ERROR;
}
- argv2 = Tcl_GetString(objv[2]);
- if ((CheckVersionAndConvert(interp, argv2, &argv2i, NULL) != TCL_OK)) {
+ argv2 = TclGetString(objv[2]);
+ if (CheckVersionAndConvert(interp, argv2, &argv2i, NULL) != TCL_OK) {
return TCL_ERROR;
- } else if (CheckAllRequirements (interp, objc-3, objv+3) != TCL_OK) {
- Tcl_Free (argv2i);
+ } else if (CheckAllRequirements(interp, objc-3, objv+3) != TCL_OK) {
+ ckfree(argv2i);
return TCL_ERROR;
}
- satisfies = AllRequirementsSatisfied (argv2i, objc-3, objv+3);
- Tcl_Free (argv2i);
+ satisfies = AllRequirementsSatisfied(argv2i, objc-3, objv+3);
+ ckfree(argv2i);
Tcl_SetObjResult(interp, Tcl_NewBooleanObj(satisfies));
break;
@@ -1120,18 +1171,18 @@ FindPackage(
{
Interp *iPtr = (Interp *) interp;
Tcl_HashEntry *hPtr;
- int new;
+ int isNew;
Package *pkgPtr;
- hPtr = Tcl_CreateHashEntry(&iPtr->packageTable, name, &new);
- if (new) {
+ hPtr = Tcl_CreateHashEntry(&iPtr->packageTable, name, &isNew);
+ if (isNew) {
pkgPtr = (Package *) ckalloc(sizeof(Package));
pkgPtr->version = NULL;
pkgPtr->availPtr = NULL;
pkgPtr->clientData = NULL;
Tcl_SetHashValue(hPtr, pkgPtr);
} else {
- pkgPtr = (Package *) Tcl_GetHashValue(hPtr);
+ pkgPtr = Tcl_GetHashValue(hPtr);
}
return pkgPtr;
}
@@ -1164,7 +1215,7 @@ TclFreePackageInfo(
for (hPtr = Tcl_FirstHashEntry(&iPtr->packageTable, &search);
hPtr != NULL; hPtr = Tcl_NextHashEntry(&search)) {
- pkgPtr = (Package *) Tcl_GetHashValue(hPtr);
+ pkgPtr = Tcl_GetHashValue(hPtr);
if (pkgPtr->version != NULL) {
ckfree(pkgPtr->version);
}
@@ -1188,9 +1239,9 @@ TclFreePackageInfo(
*
* CheckVersionAndConvert --
*
- * This function checks to see whether a version number has valid
- * syntax. It also generates a semi-internal representation (string
- * rep of a list of numbers).
+ * This function checks to see whether a version number has valid syntax.
+ * It also generates a semi-internal representation (string rep of a list
+ * of numbers).
*
* Results:
* If string is a properly formed version number the TCL_OK is returned.
@@ -1205,27 +1256,29 @@ TclFreePackageInfo(
static int
CheckVersionAndConvert(
- Tcl_Interp *interp, /* Used for error reporting. */
- CONST char *string, /* Supposedly a version number, which is
- * groups of decimal digits separated by
- * dots. */
- char** internal, /* Internal normalized representation */
- int* stable) /* Flag: Version is (un)stable. */
+ Tcl_Interp *interp, /* Used for error reporting. */
+ CONST char *string, /* Supposedly a version number, which is
+ * groups of decimal digits separated by
+ * dots. */
+ char **internal, /* Internal normalized representation */
+ int *stable) /* Flag: Version is (un)stable. */
{
CONST char *p = string;
char prevChar;
int hasunstable = 0;
- /* 4* assuming that each char is a separator (a,b become ' -x ').
+ /*
+ * 4* assuming that each char is a separator (a,b become ' -x ').
* 4+ to have spce for an additional -2 at the end
*/
- char* ibuf = ckalloc (4+4*strlen(string));
- char* ip = ibuf;
+ char *ibuf = ckalloc(4 + 4*strlen(string));
+ char *ip = ibuf;
- /* Basic rules
+ /*
+ * Basic rules
* (1) First character has to be a digit.
* (2) All other characters have to be a digit or '.'
* (3) Two '.'s may not follow each other.
-
+ *
* TIP 268, Modified rules
* (1) s.a.
* (2) All other characters have to be a digit, 'a', 'b', or '.'
@@ -1234,43 +1287,58 @@ CheckVersionAndConvert(
* (5) Neither 'a', nor 'b' may occur before or after a '.'
*/
- if (!isdigit(UCHAR(*p))) { /* INTL: digit */
+ if (!isdigit(UCHAR(*p))) { /* INTL: digit */
goto error;
}
*ip++ = *p;
for (prevChar = *p, p++; *p != 0; p++) {
- if (
- (!isdigit(UCHAR(*p))) &&
- (((*p != '.') && (*p != 'a') && (*p != 'b')) ||
- ((hasunstable && ((*p == 'a') || (*p == 'b'))) ||
- (((prevChar == 'a') || (prevChar == 'b') || (prevChar == '.')) && (*p == '.')) ||
- (((*p == 'a') || (*p == 'b') || (*p == '.')) && (prevChar == '.'))))
- ) {
- /* INTL: digit */
+ if (!isdigit(UCHAR(*p)) && /* INTL: digit */
+ ((*p!='.' && *p!='a' && *p!='b') ||
+ ((hasunstable && (*p=='a' || *p=='b')) ||
+ ((prevChar=='a' || prevChar=='b' || prevChar=='.')
+ && (*p=='.')) ||
+ ((*p=='a' || *p=='b' || *p=='.') && prevChar=='.')))) {
goto error;
}
- if ((*p == 'a') || (*p == 'b')) { hasunstable = 1 ; }
+ if (*p == 'a' || *p == 'b') {
+ hasunstable = 1;
+ }
- /* Translation to the internal rep. Regular version chars are copied
+ /*
+ * Translation to the internal rep. Regular version chars are copied
* as is. The separators are translated to numerics. The new separator
- * for all parts is space. */
+ * for all parts is space.
+ */
- if (*p == '.') { *ip++ = ' '; *ip++ = '0'; *ip++ = ' '; }
- else if (*p == 'a') { *ip++ = ' '; *ip++ = '-'; *ip++ = '2'; *ip++ = ' '; }
- else if (*p == 'b') { *ip++ = ' '; *ip++ = '-'; *ip++ = '1'; *ip++ = ' '; }
- else { *ip++ = *p; }
+ if (*p == '.') {
+ *ip++ = ' ';
+ *ip++ = '0';
+ *ip++ = ' ';
+ } else if (*p == 'a') {
+ *ip++ = ' ';
+ *ip++ = '-';
+ *ip++ = '2';
+ *ip++ = ' ';
+ } else if (*p == 'b') {
+ *ip++ = ' ';
+ *ip++ = '-';
+ *ip++ = '1';
+ *ip++ = ' ';
+ } else {
+ *ip++ = *p;
+ }
prevChar = *p;
}
- if ((prevChar != '.') && (prevChar != 'a') && (prevChar != 'b')) {
+ if (prevChar!='.' && prevChar!='a' && prevChar!='b') {
*ip = '\0';
if (internal != NULL) {
*internal = ibuf;
} else {
- ckfree (ibuf);
+ ckfree(ibuf);
}
if (stable != NULL) {
*stable = !hasunstable;
@@ -1279,7 +1347,7 @@ CheckVersionAndConvert(
}
error:
- ckfree (ibuf);
+ ckfree(ibuf);
Tcl_AppendResult(interp, "expected version number but got \"", string,
"\"", NULL);
return TCL_ERROR;
@@ -1306,30 +1374,29 @@ CheckVersionAndConvert(
static int
CompareVersions(
- char *v1, /* Versions strings, of form 2.1.3 (any number */
- char *v2, /* of version numbers). */
- int *isMajorPtr) /* If non-null, the word pointed to is filled
- * in with a 0/1 value. 1 means that the difference
- * occured in the first element. */
+ char *v1, char *v2, /* Versions strings, of form 2.1.3 (any number
+ * of version numbers). */
+ int *isMajorPtr) /* If non-null, the word pointed to is filled
+ * in with a 0/1 value. 1 means that the
+ * difference occured in the first element. */
{
- int thisIsMajor;
- int res, flip;
- char* s1, *e1, *s2, *e2, o1, o2;
+ int thisIsMajor, res, flip;
+ char *s1, *e1, *s2, *e2, o1, o2;
/*
* Each iteration of the following loop processes one number from each
- * string, terminated by a " " (space). If those numbers don't match then the
- * comparison is over; otherwise, we loop back for the next number.
+ * string, terminated by a " " (space). If those numbers don't match then
+ * the comparison is over; otherwise, we loop back for the next number.
*
* TIP 268.
* This is identical the function 'ComparePkgVersion', but using the new
* space separator as used by the internal rep of version numbers. The
* special separators 'a' and 'b' have already been dealt with in
- * 'CheckVersionAndConvert', they were translated into numbers as
- * well. This keeps the comparison sane. Otherwise we would have to
- * compare numerics, the separators, and also deal with the special case
- * of end-of-string compared to separators. The semi-list rep we get here
- * is much easier to handle, as it is still regular.
+ * 'CheckVersionAndConvert', they were translated into numbers as well.
+ * This keeps the comparison sane. Otherwise we would have to compare
+ * numerics, the separators, and also deal with the special case of
+ * end-of-string compared to separators. The semi-list rep we get here is
+ * much easier to handle, as it is still regular.
*
* Rewritten to not compute a numeric value for the extracted version
* number, but do string comparison. Skip any leading zeros for that to
@@ -1342,13 +1409,17 @@ CompareVersions(
while (1) {
/*
- * Parse one decimal number from the front of each string.
- * Skip leading zeros. Terminate found number for upcoming
- * string-wise comparison, if needed.
+ * Parse one decimal number from the front of each string. Skip
+ * leading zeros. Terminate found number for upcoming string-wise
+ * comparison, if needed.
*/
- while ((*s1 != 0) && (*s1 == '0')) { s1 ++; }
- while ((*s2 != 0) && (*s2 == '0')) { s2 ++; }
+ while ((*s1 != 0) && (*s1 == '0')) {
+ s1++;
+ }
+ while ((*s2 != 0) && (*s2 == '0')) {
+ s2++;
+ }
/*
* s1, s2 now point to the beginnings of the numbers to compare. Test
@@ -1371,8 +1442,8 @@ CompareVersions(
if ((*s1 == '-') && (*s2 == '-')) {
/* a < b => -a > -b, etc. */
- s1 ++;
- s2 ++;
+ s1++;
+ s2++;
flip = 1;
} else {
flip = 0;
@@ -1383,12 +1454,18 @@ CompareVersions(
* numbers end.
*/
- e1 = s1; while ((*e1 != 0) && (*e1 != ' ')) { e1 ++; }
- e2 = s2; while ((*e2 != 0) && (*e2 != ' ')) { e2 ++; }
+ e1 = s1;
+ while ((*e1 != 0) && (*e1 != ' ')) {
+ e1++;
+ }
+ e2 = s2;
+ while ((*e2 != 0) && (*e2 != ' ')) {
+ e2++;
+ }
/*
* s1 .. e1 and s2 .. e2 now bracket the numbers to compare. Insert
- * terminators, compare, and restore actual contents. First however
+ * terminators, compare, and restore actual contents. First however
* another shortcut. Compare lengths. Shorter string is smaller
* number! Thus we strcmp only strings of identical length.
*/
@@ -1398,10 +1475,12 @@ CompareVersions(
} else if ((e2-s2) < (e1-s1)) {
res = 1;
} else {
- o1 = *e1 ; *e1 = '\0';
- o2 = *e2 ; *e2 = '\0';
+ o1 = *e1;
+ *e1 = '\0';
+ o2 = *e2;
+ *e2 = '\0';
- res = strcmp (s1, s2);
+ res = strcmp(s1, s2);
res = (res < 0) ? -1 : (res ? 1 : 0);
*e1 = o1;
@@ -1414,7 +1493,9 @@ CompareVersions(
*/
if (res != 0) {
- if (flip) res = -res;
+ if (flip) {
+ res = -res;
+ }
break;
}
@@ -1452,13 +1533,12 @@ CompareVersions(
*
* CheckAllRequirements --
*
- * This function checks to see whether all requirements in a set
- * have valid syntax.
+ * This function checks to see whether all requirements in a set have
+ * valid syntax.
*
* Results:
- * TCL_OK is returned if all requirements are valid.
- * Otherwise TCL_ERROR is returned and an error message
- * is left in the interp's result.
+ * TCL_OK is returned if all requirements are valid. Otherwise TCL_ERROR
+ * is returned and an error message is left in the interp's result.
*
* Side effects:
* May modify the interpreter result.
@@ -1468,13 +1548,14 @@ CompareVersions(
static int
CheckAllRequirements(
- Tcl_Interp* interp,
- int reqc, /* Requirements to check. */
+ Tcl_Interp *interp,
+ int reqc, /* Requirements to check. */
Tcl_Obj *CONST reqv[])
{
int i;
+
for (i = 0; i < reqc; i++) {
- if ((CheckRequirement(interp, Tcl_GetString(reqv[i])) != TCL_OK)) {
+ if ((CheckRequirement(interp, TclGetString(reqv[i])) != TCL_OK)) {
return TCL_ERROR;
}
}
@@ -1504,44 +1585,52 @@ CheckRequirement(
Tcl_Interp *interp, /* Used for error reporting. */
CONST char *string) /* Supposedly a requirement. */
{
- /* Syntax of requirement = version
- * = version-version
- * = version-
+ /*
+ * Syntax of requirement = version
+ * = version-version
+ * = version-
*/
- char* dash = NULL;
- char* buf;
+ char *dash = NULL, *buf;
- dash = strchr (string, '-');
+ dash = strchr(string, '-');
if (dash == NULL) {
- /* no dash found, has to be a simple version */
- return CheckVersionAndConvert (interp, string, NULL, NULL);
+ /*
+ * no dash found, has to be a simple version.
+ */
+
+ return CheckVersionAndConvert(interp, string, NULL, NULL);
}
- if (strchr (dash+1, '-') != NULL) {
- /* More dashes found after the first. This is wrong. */
- Tcl_AppendResult(interp, "expected versionMin-versionMax but got \"", string,
- "\"", NULL);
+
+ if (strchr(dash+1, '-') != NULL) {
+ /*
+ * More dashes found after the first. This is wrong.
+ */
+
+ Tcl_AppendResult(interp, "expected versionMin-versionMax but got \"",
+ string, "\"", NULL);
return TCL_ERROR;
}
- /* Exactly one dash is present. Copy the string, split at the location of
+ /*
+ * Exactly one dash is present. Copy the string, split at the location of
* dash and check that both parts are versions. Note that the max part can
* be empty.
*/
- buf = strdup (string);
- dash = buf + (dash - string);
- *dash = '\0'; /* buf now <=> min part */
- dash ++; /* dash now <=> max part */
+ DupString(buf, string);
+ dash = buf + (dash - string);
+ *dash = '\0'; /* buf now <=> min part */
+ dash++; /* dash now <=> max part */
if ((CheckVersionAndConvert(interp, buf, NULL, NULL) != TCL_OK) ||
- ((*dash != '\0') &&
- (CheckVersionAndConvert(interp, dash, NULL, NULL) != TCL_OK))) {
- free (buf);
+ ((*dash != '\0') &&
+ (CheckVersionAndConvert(interp, dash, NULL, NULL) != TCL_OK))) {
+ ckfree(buf);
return TCL_ERROR;
}
- free (buf);
+ ckfree(buf);
return TCL_OK;
}
@@ -1563,12 +1652,15 @@ CheckRequirement(
static void
AddRequirementsToResult(
- Tcl_Interp* interp,
- int reqc, /* Requirements constraining the desired version. */
- Tcl_Obj *CONST reqv[]) /* 0 means to use the latest version available. */
+ Tcl_Interp *interp,
+ int reqc, /* Requirements constraining the desired
+ * version. */
+ Tcl_Obj *CONST reqv[]) /* 0 means to use the latest version
+ * available. */
{
if (reqc > 0) {
int i;
+
for (i = 0; i < reqc; i++) {
Tcl_AppendResult(interp, " ", TclGetString(reqv[i]), NULL);
}
@@ -1593,15 +1685,18 @@ AddRequirementsToResult(
static void
AddRequirementsToDString(
- Tcl_DString* dstring,
- int reqc, /* Requirements constraining the desired version. */
- Tcl_Obj *CONST reqv[]) /* 0 means to use the latest version available. */
+ Tcl_DString *dsPtr,
+ int reqc, /* Requirements constraining the desired
+ * version. */
+ Tcl_Obj *CONST reqv[]) /* 0 means to use the latest version
+ * available. */
{
if (reqc > 0) {
int i;
+
for (i = 0; i < reqc; i++) {
- Tcl_DStringAppend(dstring, " ", 1);
- Tcl_DStringAppend(dstring, TclGetString(reqv[i]), -1);
+ Tcl_DStringAppend(dsPtr, " ", 1);
+ Tcl_DStringAppend(dsPtr, TclGetString(reqv[i]), -1);
}
}
}
@@ -1611,14 +1706,13 @@ AddRequirementsToDString(
*
* AllRequirementSatisfied --
*
- * This function checks to see whether a version satisfies at
- * least one of a set of requirements.
+ * This function checks to see whether a version satisfies at least one
+ * of a set of requirements.
*
* Results:
- * If the requirements are satisfied 1 is returned.
- * Otherwise 0 is returned. The function assumes
- * that all pieces have valid syntax. And is allowed
- * to make that assumption.
+ * If the requirements are satisfied 1 is returned. Otherwise 0 is
+ * returned. The function assumes that all pieces have valid syntax. And
+ * is allowed to make that assumption.
*
* Side effects:
* None.
@@ -1628,17 +1722,21 @@ AddRequirementsToDString(
static int
AllRequirementsSatisfied(
- char* availVersionI, /* Candidate version to check against the requirements */
- int reqc, /* Requirements constraining the desired version. */
- Tcl_Obj *CONST reqv[]) /* 0 means to use the latest version available. */
+ char *availVersionI, /* Candidate version to check against the
+ * requirements. */
+ int reqc, /* Requirements constraining the desired
+ * version. */
+ Tcl_Obj *CONST reqv[]) /* 0 means to use the latest version
+ * available. */
{
- int i, satisfies;
+ int i;
- for (satisfies = i = 0; i < reqc; i++) {
- satisfies = RequirementSatisfied(availVersionI, Tcl_GetString(reqv[i]));
- if (satisfies) break;
+ for (i = 0; i < reqc; i++) {
+ if (RequirementSatisfied(availVersionI, TclGetString(reqv[i]))) {
+ return 1;
+ }
}
- return satisfies;
+ return 0;
}
/*
@@ -1649,10 +1747,9 @@ AllRequirementsSatisfied(
* This function checks to see whether a version satisfies a requirement.
*
* Results:
- * If the requirement is satisfied 1 is returned.
- * Otherwise 0 is returned. The function assumes
- * that all pieces have valid syntax. And is allowed
- * to make that assumption.
+ * If the requirement is satisfied 1 is returned. Otherwise 0 is
+ * returned. The function assumes that all pieces have valid syntax, and
+ * is allowed to make that assumption.
*
* Side effects:
* None.
@@ -1662,79 +1759,84 @@ AllRequirementsSatisfied(
static int
RequirementSatisfied(
- char *havei, /* Version string, of candidate package we have */
- CONST char *req) /* Requirement string the candidate has to satisfy */
+ char *havei, /* Version string, of candidate package we
+ * have. */
+ CONST char *req) /* Requirement string the candidate has to
+ * satisfy. */
{
- /* The have candidate is already in internal rep. */
+ /*
+ * The have candidate is already in internal rep.
+ */
int satisfied, res;
- char* dash = NULL;
- char* buf, *min, *max;
+ char *dash = NULL, *buf, *min, *max;
- dash = strchr (req, '-');
+ dash = strchr(req, '-');
if (dash == NULL) {
- /* No dash found, is a simple version, fallback to regular check.
- * The 'CheckVersionAndConvert' cannot fail. We pad the requirement with
+ /*
+ * No dash found, is a simple version, fallback to regular check. The
+ * 'CheckVersionAndConvert' cannot fail. We pad the requirement with
* 'a0', i.e '-2' before doing the comparison to properly accept
* unstables as well.
*/
- char* reqi = NULL;
+ char *reqi = NULL;
int thisIsMajor;
- CheckVersionAndConvert (NULL, req, &reqi, NULL);
- strcat (reqi, " -2");
- res = CompareVersions(havei, reqi, &thisIsMajor);
+ CheckVersionAndConvert(NULL, req, &reqi, NULL);
+ strcat(reqi, " -2");
+ res = CompareVersions(havei, reqi, &thisIsMajor);
satisfied = (res == 0) || ((res == 1) && !thisIsMajor);
- Tcl_Free (reqi);
+ ckfree(reqi);
return satisfied;
}
- /* Exactly one dash is present (Assumption of valid syntax). Copy the req,
- * split at the location of dash and check that both parts are
- * versions. Note that the max part can be empty.
+ /*
+ * Exactly one dash is present (Assumption of valid syntax). Copy the req,
+ * split at the location of dash and check that both parts are versions.
+ * Note that the max part can be empty.
*/
- buf = strdup (req);
- dash = buf + (dash - req);
- *dash = '\0'; /* buf now <=> min part */
- dash ++; /* dash now <=> max part */
+ DupString(buf, req);
+ dash = buf + (dash - req);
+ *dash = '\0'; /* buf now <=> min part */
+ dash++; /* dash now <=> max part */
if (*dash == '\0') {
- /* We have a min, but no max. For the comparison we generate the
+ /*
+ * We have a min, but no max. For the comparison we generate the
* internal rep, padded with 'a0' i.e. '-2'.
*/
- /* No max part, unbound */
-
- CheckVersionAndConvert (NULL, buf, &min, NULL);
- strcat (min, " -2");
+ CheckVersionAndConvert(NULL, buf, &min, NULL);
+ strcat(min, " -2");
satisfied = (CompareVersions(havei, min, NULL) >= 0);
- Tcl_Free (min);
- free (buf);
+ ckfree(min);
+ ckfree(buf);
return satisfied;
}
- /* We have both min and max, and generate their internal reps.
- * When identical we compare as is, otherwise we pad with 'a0'
- * to ove the range a bit.
+ /*
+ * We have both min and max, and generate their internal reps. When
+ * identical we compare as is, otherwise we pad with 'a0' to ove the range
+ * a bit.
*/
- CheckVersionAndConvert (NULL, buf, &min, NULL);
- CheckVersionAndConvert (NULL, dash, &max, NULL);
+ CheckVersionAndConvert(NULL, buf, &min, NULL);
+ CheckVersionAndConvert(NULL, dash, &max, NULL);
if (CompareVersions(min, max, NULL) == 0) {
satisfied = (CompareVersions(min, havei, NULL) == 0);
} else {
- strcat (min, " -2");
- strcat (max, " -2");
+ strcat(min, " -2");
+ strcat(max, " -2");
satisfied = ((CompareVersions(min, havei, NULL) <= 0) &&
- (CompareVersions(havei, max, NULL) < 0));
+ (CompareVersions(havei, max, NULL) < 0));
}
- Tcl_Free (min);
- Tcl_Free (max);
- free (buf);
+ ckfree(min);
+ ckfree(max);
+ ckfree(buf);
return satisfied;
}
@@ -1743,9 +1845,9 @@ RequirementSatisfied(
*
* ExactRequirement --
*
- * This function is the core for the translation of -exact requests.
- * It translates the request of the version into a range of versions.
- * The translation was chosen for backwards compatibility.
+ * This function is the core for the translation of -exact requests. It
+ * translates the request of the version into a range of versions. The
+ * translation was chosen for backwards compatibility.
*
* Results:
* A Tcl_Obj containing the version range as string.
@@ -1756,17 +1858,18 @@ RequirementSatisfied(
*----------------------------------------------------------------------
*/
-static Tcl_Obj*
-ExactRequirement(version)
- CONST char* version;
+static Tcl_Obj *
+ExactRequirement(
+ CONST char *version)
{
- /* A -exact request for a version X.y is translated into the range
+ /*
+ * A -exact request for a version X.y is translated into the range
* X.y-X.(y+1). For example -exact 8.4 means the range "8.4-8.5".
*
* This translation was chosen to prevent packages which currently use a
* 'package require -exact tclversion' from being affected by the core now
- * registering itself as 8.4.x (patchlevel) instead of 8.4
- * (version). Examples are tbcload, compiler, and ITcl.
+ * registering itself as 8.4.x (patchlevel) instead of 8.4 (version).
+ * Examples are tbcload, compiler, and ITcl.
*
* Translating -exact 8.4 to the range "8.4-8.4" instead would require us
* and everyone else to rebuild these packages to require -exact 8.4.14,
@@ -1774,53 +1877,70 @@ ExactRequirement(version)
* issue with effects similar to the bugfix made in 8.5 now requiring
* ifneeded and provided versions to match. Instead we have chosen to
* interpret exactness to not be exactly equal, but to be exact only
- * within the specified level, and allowing variation in the deeper
- * level. More examples:
+ * within the specified level, and allowing variation in the deeper level.
+ * More examples:
*
- * -exact 8 => "8-9"
+ * -exact 8 => "8-9"
* -exact 8.4 => "8.4-8.5"
* -exact 8.4.14 => "8.4.14-8.4.15"
* -exact 8.0a2 => "8.0a2-8.0a3"
*/
- char* iv;
- int lc, i;
- CONST char** lv;
- char buf [30];
- Tcl_Obj* o = Tcl_NewStringObj (version,-1);
- Tcl_AppendStringsToObj (o, "-", NULL);
+ char *iv, buf[30];
+ int lc, i;
+ CONST char **lv;
+ Tcl_Obj *objPtr = Tcl_NewStringObj(version, -1);
+
+ Tcl_AppendStringsToObj(objPtr, "-", NULL);
- /* Assuming valid syntax here */
- CheckVersionAndConvert (NULL, version, &iv, NULL);
+ /*
+ * Assuming valid syntax here.
+ */
- /* Split the list into components */
- Tcl_SplitList (NULL, iv, &lc, &lv);
+ CheckVersionAndConvert(NULL, version, &iv, NULL);
- /* Iterate over the components and make them parts of the result. Except
- * for the last, which is handled separately, to allow the
- * incrementation.
+ /*
+ * Split the list into components.
+ */
+
+ Tcl_SplitList(NULL, iv, &lc, &lv);
+
+ /*
+ * Iterate over the components and make them parts of the result. Except
+ * for the last, which is handled separately, to allow the incrementation.
*/
for (i=0; i < (lc-1); i++) {
- /* Regular component */
- Tcl_AppendStringsToObj (o, lv[i], NULL);
- /* Separator component */
- i ++;
- if (0 == strcmp ("-1", lv[i])) {
- Tcl_AppendStringsToObj (o, "b", NULL);
- } else if (0 == strcmp ("-2", lv[i])) {
- Tcl_AppendStringsToObj (o, "a", NULL);
+ /*
+ * Regular component.
+ */
+
+ Tcl_AppendStringsToObj(objPtr, lv[i], NULL);
+
+ /*
+ * Separator component.
+ */
+
+ i++;
+ if (0 == strcmp("-1", lv[i])) {
+ Tcl_AppendStringsToObj(objPtr, "b", NULL);
+ } else if (0 == strcmp("-2", lv[i])) {
+ Tcl_AppendStringsToObj(objPtr, "a", NULL);
} else {
- Tcl_AppendStringsToObj (o, ".", NULL);
+ Tcl_AppendStringsToObj(objPtr, ".", NULL);
}
}
- /* Regular component, last */
- sprintf (buf, "%d", atoi (lv [lc-1]) + 1);
- Tcl_AppendStringsToObj (o, buf, NULL);
- ckfree ((char*) iv);
- ckfree ((char*) lv);
- return o;
+ /*
+ * Regular component, last.
+ */
+
+ sprintf(buf, "%d", atoi(lv[lc-1]) + 1);
+ Tcl_AppendStringsToObj(objPtr, buf, NULL);
+
+ ckfree((char *) iv);
+ ckfree((char *) lv);
+ return objPtr;
}
/*
@@ -1842,14 +1962,14 @@ ExactRequirement(version)
*/
static void
-VersionCleanupProc (
+VersionCleanupProc(
ClientData clientData, /* Pointer to remembered version string object
* for interp. */
Tcl_Interp *interp) /* Interpreter that is being deleted. */
{
- Tcl_Obj* ov = (Tcl_Obj*) clientData;
+ Tcl_Obj *ov = clientData;
if (ov != NULL) {
- Tcl_DecrRefCount (ov);
+ TclDecrRefCount(ov);
}
}
generated by cgit v0.12 at 2024-07-17 18:57:23 (GMT)