summaryrefslogtreecommitdiffstats
path: root/generic/tclIORTrans.c
diff options
context:
space:
mode:
Diffstat (limited to 'generic/tclIORTrans.c')
-rw-r--r--generic/tclIORTrans.c994
1 files changed, 507 insertions, 487 deletions
diff --git a/generic/tclIORTrans.c b/generic/tclIORTrans.c
index 55d0807..b550675 100644
--- a/generic/tclIORTrans.c
+++ b/generic/tclIORTrans.c
@@ -15,7 +15,7 @@
* See the file "license.terms" for information on usage and redistribution of
* this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * RCS: @(#) $Id: tclIORTrans.c,v 1.5 2008/10/17 18:06:08 andreas_kupries Exp $
+ * RCS: @(#) $Id: tclIORTrans.c,v 1.6 2008/10/26 18:34:04 dkf Exp $
*/
#include <tclInt.h>
@@ -56,32 +56,32 @@ static int ReflectSetOption(ClientData clientData,
Tcl_Interp *interp, const char *optionName,
const char *newValue);
static int ReflectHandle(ClientData clientData, int direction,
- ClientData* handle);
+ ClientData *handle);
static int ReflectNotify(ClientData clientData, int mask);
/*
- * The C layer channel type/driver definition used by the reflection. This is
- * a version 3 structure.
+ * The C layer channel type/driver definition used by the reflection.
*/
static Tcl_ChannelType tclRTransformType = {
- "tclrtransform", /* Type name. */
- TCL_CHANNEL_VERSION_5, /* v5 channel */
- ReflectClose, /* Close channel, clean instance data */
- ReflectInput, /* Handle read request */
- ReflectOutput, /* Handle write request */
- ReflectSeek, /* Move location of access point. */
- ReflectSetOption, /* Set options. */
- ReflectGetOption, /* Get options. */
- ReflectWatch, /* Initialize notifier */
- ReflectHandle, /* Get OS handle from the channel. */
- NULL, /* No close2 support. NULL'able */
- ReflectBlock, /* Set blocking/nonblocking. */
- NULL, /* Flush channel. Not used by core. NULL'able */
- ReflectNotify, /* Handle events. */
- ReflectSeekWide, /* Move access point (64 bit). */
- NULL, /* thread action */
- NULL, /* truncate */
+ "tclrtransform", /* Type name. */
+ TCL_CHANNEL_VERSION_5, /* v5 channel. */
+ ReflectClose, /* Close channel, clean instance data. */
+ ReflectInput, /* Handle read request. */
+ ReflectOutput, /* Handle write request. */
+ ReflectSeek, /* Move location of access point. */
+ ReflectSetOption, /* Set options. */
+ ReflectGetOption, /* Get options. */
+ ReflectWatch, /* Initialize notifier. */
+ ReflectHandle, /* Get OS handle from the channel. */
+ NULL, /* No close2 support. NULL'able */
+ ReflectBlock, /* Set blocking/nonblocking. */
+ NULL, /* Flush channel. Not used by core.
+ * NULL'able. */
+ ReflectNotify, /* Handle events. */
+ ReflectSeekWide, /* Move access point (64 bit). */
+ NULL, /* thread action */
+ NULL, /* truncate */
};
/*
@@ -90,18 +90,21 @@ static Tcl_ChannelType tclRTransformType = {
*/
typedef struct _ResultBuffer_ {
- unsigned char* buf; /* Reference to the buffer area */
- int allocated; /* Allocated size of the buffer area */
- int used; /* Number of bytes in the buffer, <= allocated */
+ unsigned char *buf; /* Reference to the buffer area. */
+ int allocated; /* Allocated size of the buffer area. */
+ int used; /* Number of bytes in the buffer,
+ * <= allocated. */
} ResultBuffer;
#define ResultLength(r) ((r)->used)
-/* static int ResultLength (ResultBuffer* r); */
+/* static int ResultLength (ResultBuffer *r); */
-static void ResultClear (ResultBuffer* r);
-static void ResultInit (ResultBuffer* r);
-static void ResultAdd (ResultBuffer* r, unsigned char* buf, int toWrite);
-static int ResultCopy (ResultBuffer* r, unsigned char* buf, int toRead);
+static void ResultClear(ResultBuffer *r);
+static void ResultInit(ResultBuffer *r);
+static void ResultAdd(ResultBuffer *r, unsigned char *buf,
+ int toWrite);
+static int ResultCopy(ResultBuffer *r, unsigned char *buf,
+ int toRead);
#define RB_INCREMENT (512)
@@ -118,15 +121,14 @@ static int ResultCopy (ResultBuffer* r, unsigned char* buf, int toRe
typedef struct {
Tcl_Channel chan; /* Back reference to the channel of the
* transformation itself. */
- Tcl_Channel parent; /* Reference to the channel the transformation
+ Tcl_Channel parent; /* Reference to the channel the transformation
* was pushed on. */
Tcl_Interp *interp; /* Reference to the interpreter containing the
* Tcl level part of the channel. */
- Tcl_Obj *handle; /* Reference to transform handle. Also stored
+ Tcl_Obj *handle; /* Reference to transform handle. Also stored
* in the argv, see below. The separate field
* gives us direct access, needed when working
- * with the reflection maps.
- */
+ * with the reflection maps. */
#ifdef TCL_THREADS
Tcl_ThreadId thread; /* Thread the 'interp' belongs to. */
#endif
@@ -144,14 +146,14 @@ typedef struct {
* CT = Belongs to the 'Command handler Thread'.
*/
- int argc; /* Number of preallocated words - 2 */
+ int argc; /* Number of preallocated words - 2. */
Tcl_Obj **argv; /* Preallocated array for calling the handler.
* args[0] is placeholder for cmd word.
* Followed by the arguments in the prefix,
* plus 4 placeholders for method, channel,
* and at most two varying (method specific)
* words. */
- int methods; /* Bitmask of supported methods */
+ int methods; /* Bitmask of supported methods. */
/*
* NOTE (9): Should we have predefined shared literals for the method
@@ -159,11 +161,9 @@ typedef struct {
*/
int mode; /* Mask of R/W mode */
- int nonblocking; /* Flag: Channel is blocking or not */
- int readIsDrained; /* Flag: Read buffers are flushed*/
-
+ int nonblocking; /* Flag: Channel is blocking or not. */
+ int readIsDrained; /* Flag: Read buffers are flushed. */
ResultBuffer result;
-
} ReflectedTransform;
/*
@@ -243,9 +243,9 @@ typedef enum {
/*
* Event used to forward driver invocations to the thread actually managing
- * the channel. We cannot construct the command to execute and forward
- * that. Because then it will contain a mixture of Tcl_Obj's belonging to both
- * the command handler thread (CT), and the thread managing the channel (MT),
+ * the channel. We cannot construct the command to execute and forward that.
+ * Because then it will contain a mixture of Tcl_Obj's belonging to both the
+ * command handler thread (CT), and the thread managing the channel (MT),
* executed in CT. Tcl_Obj's are not allowed to cross thread boundaries. So we
* forward an operation code, the argument details, and reference to results.
* The command is assembled in the CT and belongs fully to that thread. No
@@ -284,7 +284,7 @@ struct ForwardParamLimit {
typedef union ForwardParam {
ForwardParamBase base;
struct ForwardParamTransform transform;
- struct ForwardParamLimit limit;
+ struct ForwardParamLimit limit;
} ForwardParam;
/*
@@ -333,7 +333,7 @@ typedef struct ThreadSpecificData {
* Table of all reflected transformations owned by this thread.
*/
- ReflectedTransformMap* rtmPtr;
+ ReflectedTransformMap *rtmPtr;
} ThreadSpecificData;
static Tcl_ThreadDataKey dataKey;
@@ -358,7 +358,7 @@ TCL_DECLARE_MUTEX(rtForwardMutex)
*/
static void ForwardOpToOwnerThread(ReflectedTransform *rtPtr,
- ForwardedOperation op, const VOID *param);
+ ForwardedOperation op, const void *param);
static int ForwardProc(Tcl_Event *evPtr, int mask);
static void SrcExitProc(ClientData clientData);
@@ -424,41 +424,50 @@ static void DeleteReflectedTransformMap(ClientData clientData,
* list-quoting to keep the words of the message together. See also [x].
*/
-static const char *msg_read_badlimit = "{Tcl driver returned bad read limit '0'}";
+static const char *msg_read_badlimit =
+ "{Tcl driver returned bad read limit '0'}";
static const char *msg_read_unsup = "{read not supported by Tcl driver}";
static const char *msg_write_unsup = "{write not supported by Tcl driver}";
#ifdef TCL_THREADS
static const char *msg_send_originlost = "{Channel thread lost}";
static const char *msg_send_dstlost = "{Owner lost}";
#endif /* TCL_THREADS */
-static const char *msg_dstlost = "-code 1 -level 0 -errorcode NONE -errorinfo {} -errorline 1 {Owner lost}";
+static const char *msg_dstlost =
+ "-code 1 -level 0 -errorcode NONE -errorinfo {} -errorline 1 {Owner lost}";
/*
* Timer management (flushing out buffered data via artificial events).
*/
/*
- * Number of milliseconds to wait before firing an event to try to
- * flush out information waiting in buffers (fileevent support).
+ * Number of milliseconds to wait before firing an event to try to flush out
+ * information waiting in buffers (fileevent support).
*/
#define FLUSH_DELAY (5)
-static void TimerKill (ReflectedTransform* rtPtr);
-static void TimerSetup (ReflectedTransform* rtPtr);
-static void TimerRun (ClientData clientData);
+static void TimerKill(ReflectedTransform* rtPtr);
+static void TimerSetup(ReflectedTransform* rtPtr);
+static void TimerRun(ClientData clientData);
/*
* Helper functions encapsulating some of the thread forwarding to make the
* control flow in callers easier.
*/
-static int TransformRead (ReflectedTransform* rtPtr, int* errorCodePtr, unsigned char* buf, int toRead);
-static int TransformWrite (ReflectedTransform* rtPtr, int* errorCodePtr, unsigned char* buf, int toWrite);
-static int TransformDrain (ReflectedTransform* rtPtr, int* errorCodePtr);
-static int TransformFlush (ReflectedTransform* rtPtr, int* errorCodePtr, int op);
-static void TransformClear (ReflectedTransform* rtPtr);
-static int TransformLimit (ReflectedTransform* rtPtr, int* errorCodePtr, int* maxPtr);
+static int TransformRead(ReflectedTransform *rtPtr,
+ int *errorCodePtr, unsigned char *buf,
+ int toRead);
+static int TransformWrite(ReflectedTransform *rtPtr,
+ int *errorCodePtr, unsigned char *buf,
+ int toWrite);
+static int TransformDrain(ReflectedTransform *rtPtr,
+ int *errorCodePtr);
+static int TransformFlush(ReflectedTransform *rtPtr,
+ int *errorCodePtr, int op);
+static void TransformClear(ReflectedTransform *rtPtr);
+static int TransformLimit(ReflectedTransform *rtPtr,
+ int *errorCodePtr, int *maxPtr);
/* op'codes for TransformFlush */
#define FLUSH_WRITE 1
@@ -467,14 +476,14 @@ static int TransformLimit (ReflectedTransform* rtPtr, int* errorCodePtr, int* m
/*
* Main methods to plug into the 'chan' ensemble'. ==================
*/
-
+
/*
*----------------------------------------------------------------------
*
* TclChanPushObjCmd --
*
- * This function is invoked to process the "chan push" Tcl command.
- * See the user documentation for details on what it does.
+ * This function is invoked to process the "chan push" Tcl command. See
+ * the user documentation for details on what it does.
*
* Results:
* A standard Tcl result. The handle of the new channel is placed in the
@@ -493,17 +502,17 @@ TclChanPushObjCmd(
int objc,
Tcl_Obj *const *objv)
{
- ReflectedTransform *rtPtr; /* Instance data of the new (transform) channel */
- Tcl_Obj* chanObj; /* Handle of parent channel */
- Tcl_Channel parentChan; /* Token of parent channel */
- int mode; /* R/W mode of parent, later the new
- * channel. Has to match the abilities of the
- * handler commands */
+ ReflectedTransform *rtPtr; /* Instance data of the new (transform)
+ * channel. */
+ Tcl_Obj *chanObj; /* Handle of parent channel */
+ Tcl_Channel parentChan; /* Token of parent channel */
+ int mode; /* R/W mode of parent, later the new channel.
+ * Has to match the abilities of the handler
+ * commands */
Tcl_Obj *cmdObj; /* Command prefix, list of words */
Tcl_Obj *cmdNameObj; /* Command name */
Tcl_Obj *rtId; /* Handle of the new transform (channel) */
Tcl_Obj *modeObj; /* mode in obj form for method call */
-
int listc; /* Result of 'initialize', and of */
Tcl_Obj **listv; /* its sublist in the 2nd element */
int methIndex; /* Encoded method name */
@@ -512,8 +521,8 @@ TclChanPushObjCmd(
int methods; /* Bitmask for supported methods. */
Tcl_Obj *err; /* Error message */
ReflectedTransformMap *rtmPtr;
- /* Map of reflected transforms with handlers in
- * this interp. */
+ /* Map of reflected transforms with handlers
+ * in this interp. */
Tcl_HashEntry *hPtr; /* Entry in the above map */
int isNew; /* Placeholder. */
@@ -541,16 +550,16 @@ TclChanPushObjCmd(
* First argument is a channel handle.
*/
- chanObj = objv[CHAN];
- parentChan = Tcl_GetChannel (interp, Tcl_GetString (chanObj), &mode);
+ chanObj = objv[CHAN];
+ parentChan = Tcl_GetChannel(interp, Tcl_GetString(chanObj), &mode);
if (parentChan == NULL) {
return TCL_ERROR;
}
- parentChan = Tcl_GetTopChannel (parentChan);
+ parentChan = Tcl_GetTopChannel(parentChan);
/*
* Second argument is command prefix, i.e. list of words, first word is
- * name of handler command, other words are fixed arguments. Run
+ * name of handler command, other words are fixed arguments. Run the
* 'initialize' method to get the list of supported methods. Validate
* this.
*/
@@ -588,9 +597,8 @@ TclChanPushObjCmd(
/*
* Verify the result.
- * - List, of method names. Convert to mask.
- * Check for non-optionals through the mask.
- * Compare open mode against optional r/w.
+ * - List, of method names. Convert to mask. Check for non-optionals
+ * through the mask. Compare open mode against optional r/w.
*/
if (Tcl_ListObjGetElements(NULL, resObj, &listc, &listv) != TCL_OK) {
@@ -637,8 +645,12 @@ TclChanPushObjCmd(
* also be supported by the handler, by design of the check.
*/
- if (!HAS(methods, METH_READ)) { mode &= ~TCL_READABLE; }
- if (!HAS(methods, METH_WRITE)) { mode &= ~TCL_WRITABLE; }
+ if (!HAS(methods, METH_READ)) {
+ mode &= ~TCL_READABLE;
+ }
+ if (!HAS(methods, METH_WRITE)) {
+ mode &= ~TCL_WRITABLE;
+ }
if (!mode) {
TclNewLiteralStringObj(err, "chan handler \"");
@@ -675,27 +687,24 @@ TclChanPushObjCmd(
*/
rtPtr->methods = methods;
- rtPtr->mode = mode;
- rtPtr->chan = Tcl_StackChannel (interp, &tclRTransformType,
- (ClientData) rtPtr, mode,
- rtPtr->parent);
+ rtPtr->mode = mode;
+ rtPtr->chan = Tcl_StackChannel(interp, &tclRTransformType, rtPtr, mode,
+ rtPtr->parent);
/*
* Register the transform in our our map for proper handling of deleted
* interpreters and/or threads.
*/
- rtmPtr = GetReflectedTransformMap (interp);
- hPtr = Tcl_CreateHashEntry(&rtmPtr->map, Tcl_GetString(rtId),
- &isNew);
+ rtmPtr = GetReflectedTransformMap(interp);
+ hPtr = Tcl_CreateHashEntry(&rtmPtr->map, Tcl_GetString(rtId), &isNew);
if (!isNew && rtPtr != Tcl_GetHashValue(hPtr)) {
Tcl_Panic("TclChanPushObjCmd: duplicate transformation handle");
}
Tcl_SetHashValue(hPtr, rtPtr);
#ifdef TCL_THREADS
rtmPtr = GetThreadReflectedTransformMap();
- hPtr = Tcl_CreateHashEntry(&rtmPtr->map, Tcl_GetString(rtId),
- &isNew);
+ hPtr = Tcl_CreateHashEntry(&rtmPtr->map, Tcl_GetString(rtId), &isNew);
Tcl_SetHashValue(hPtr, rtPtr);
#endif
@@ -703,11 +712,10 @@ TclChanPushObjCmd(
* Return the channel as the result of the command.
*/
- Tcl_AppendResult (interp, Tcl_GetChannelName (rtPtr->chan),
- (char*) NULL);
+ Tcl_AppendResult(interp, Tcl_GetChannelName(rtPtr->chan), NULL);
return TCL_OK;
- error:
+ error:
/*
* We are not going through ReflectClose as we never had a channel
* structure.
@@ -725,8 +733,8 @@ TclChanPushObjCmd(
*
* TclChanPopObjCmd --
*
- * This function is invoked to process the "chan pop" Tcl command.
- * See the user documentation for details on what it does.
+ * This function is invoked to process the "chan pop" Tcl command. See
+ * the user documentation for details on what it does.
*
* Results:
* A standard Tcl result.
@@ -757,7 +765,7 @@ TclChanPopObjCmd(
const char *chanId; /* Tcl level channel handle */
Tcl_Channel chan; /* Channel associated to the handle */
- int mode; /* Channel r/w mode */
+ int mode; /* Channel r/w mode */
/*
* Number of arguments...
@@ -774,13 +782,14 @@ TclChanPopObjCmd(
*/
chanId = TclGetString(objv[CHAN]);
- chan = Tcl_GetChannel(interp, chanId, &mode);
+ chan = Tcl_GetChannel(interp, chanId, &mode);
if (chan == NULL) {
return TCL_ERROR;
}
- /* Removing transformations is generic, and not restricted to reflected
+ /*
+ * Removing transformations is generic, and not restricted to reflected
* transformations.
*/
@@ -794,7 +803,7 @@ TclChanPopObjCmd(
* Channel error message marshalling utilities.
*/
-static Tcl_Obj*
+static Tcl_Obj *
MarshallError(
Tcl_Interp *interp)
{
@@ -848,8 +857,8 @@ UnmarshallErrorResult(
Tcl_SetObjResult(interp, lv[lc-1]);
}
- (void) Tcl_SetReturnOptions(interp, Tcl_NewListObj(numOptions, lv));
- ((Interp *)interp)->flags &= ~ERR_ALREADY_LOGGED;
+ Tcl_SetReturnOptions(interp, Tcl_NewListObj(numOptions, lv));
+ ((Interp *) interp)->flags &= ~ERR_ALREADY_LOGGED;
}
/*
@@ -878,11 +887,12 @@ ReflectClose(
ClientData clientData,
Tcl_Interp *interp)
{
- ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+ ReflectedTransform *rtPtr = clientData;
int result; /* Result code for 'close' */
Tcl_Obj *resObj; /* Result data for 'close' */
- ReflectedTransformMap *rtmPtr;/* Map of reflected transforms with handlers in
- * this interp */
+ ReflectedTransformMap *rtmPtr;
+ /* Map of reflected transforms with handlers
+ * in this interp. */
Tcl_HashEntry *hPtr; /* Entry in the above map */
if (interp == NULL) {
@@ -933,16 +943,18 @@ ReflectClose(
* that check is not necessary. We always go through 'finalize'.
*/
- if (HAS(rtPtr->methods, METH_DRAIN) && (!rtPtr->readIsDrained)) {
+ if (HAS(rtPtr->methods, METH_DRAIN) && !rtPtr->readIsDrained) {
int errorCode;
- if (!TransformDrain (rtPtr, &errorCode)) {
+
+ if (!TransformDrain(rtPtr, &errorCode)) {
return errorCode;
}
}
if (HAS(rtPtr->methods, METH_FLUSH)) {
int errorCode;
- if (!TransformFlush (rtPtr, &errorCode, FLUSH_WRITE)) {
+
+ if (!TransformFlush(rtPtr, &errorCode, FLUSH_WRITE)) {
return errorCode;
}
}
@@ -965,52 +977,55 @@ ReflectClose(
if (result != TCL_OK) {
PassReceivedErrorInterp(interp, &p);
+ return EINVAL;
}
- } else {
+ return EOK;
+ }
#endif
- result = InvokeTclMethod(rtPtr, "finalize", NULL, NULL, &resObj);
- if ((result != TCL_OK) && (interp != NULL)) {
- Tcl_SetChannelErrorInterp(interp, resObj);
- }
- Tcl_DecrRefCount(resObj); /* Remove reference we held from the
- * invoke */
+ /*
+ * Do the actual invokation of "finalize" now; we're in the right thread.
+ */
- /*
- * Remove the transform from the map before releasing the memory, to
- * prevent future accesses from finding and dereferencing a dangling
- * pointer.
- *
- * NOTE: The transform may not be in the map. This is ok, that happens
- * when the transform was created in a different interpreter and/or
- * thread and then was moved here.
- */
+ result = InvokeTclMethod(rtPtr, "finalize", NULL, NULL, &resObj);
+ if ((result != TCL_OK) && (interp != NULL)) {
+ Tcl_SetChannelErrorInterp(interp, resObj);
+ }
- rtmPtr = GetReflectedTransformMap(interp);
- hPtr = Tcl_FindHashEntry (&rtmPtr->map,
- Tcl_GetString(rtPtr->handle));
- if (hPtr) {
- Tcl_DeleteHashEntry (hPtr);
- }
-#ifdef TCL_THREADS
- /*
- * In a threaded interpreter we manage a per-thread map as well, to
- * allow us to survive if the script level pulls the rug out under a
- * channel by deleting the owning thread.
- */
+ Tcl_DecrRefCount(resObj); /* Remove reference we held from the
+ * invoke. */
- rtmPtr = GetThreadReflectedTransformMap();
- hPtr = Tcl_FindHashEntry (&rtmPtr->map,
- Tcl_GetString(rtPtr->handle));
- if (hPtr) {
- Tcl_DeleteHashEntry (hPtr);
- }
-#endif
+ /*
+ * Remove the transform from the map before releasing the memory, to
+ * prevent future accesses from finding and dereferencing a dangling
+ * pointer.
+ *
+ * NOTE: The transform may not be in the map. This is ok, that happens
+ * when the transform was created in a different interpreter and/or thread
+ * and then was moved here.
+ */
+
+ rtmPtr = GetReflectedTransformMap(interp);
+ hPtr = Tcl_FindHashEntry(&rtmPtr->map, Tcl_GetString(rtPtr->handle));
+ if (hPtr) {
+ Tcl_DeleteHashEntry(hPtr);
+ }
+
+ /*
+ * In a threaded interpreter we manage a per-thread map as well, to allow
+ * us to survive if the script level pulls the rug out under a channel by
+ * deleting the owning thread.
+ */
- FreeReflectedTransform(rtPtr);
#ifdef TCL_THREADS
+ rtmPtr = GetThreadReflectedTransformMap();
+ hPtr = Tcl_FindHashEntry(&rtmPtr->map, Tcl_GetString(rtPtr->handle));
+ if (hPtr) {
+ Tcl_DeleteHashEntry(hPtr);
}
#endif
+
+ FreeReflectedTransform(rtPtr);
return (result == TCL_OK) ? EOK : EINVAL;
}
@@ -1032,12 +1047,12 @@ ReflectClose(
static int
ReflectInput(
- ClientData clientData,
- char *buf,
- int toRead,
- int *errorCodePtr)
+ ClientData clientData,
+ char *buf,
+ int toRead,
+ int *errorCodePtr)
{
- ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+ ReflectedTransform *rtPtr = clientData;
int gotBytes, copied, read;
/*
@@ -1055,13 +1070,14 @@ ReflectInput(
gotBytes = 0;
while (toRead > 0) {
- /* Loop until the request is satisfied (or no data available from
+ /*
+ * Loop until the request is satisfied (or no data available from
* below, possibly EOF).
*/
- copied = ResultCopy (&rtPtr->result, UCHARP(buf), toRead);
- toRead -= copied;
- buf += copied;
+ copied = ResultCopy(&rtPtr->result, UCHARP(buf), toRead);
+ toRead -= copied;
+ buf += copied;
gotBytes += copied;
if (toRead == 0) {
@@ -1073,9 +1089,7 @@ ReflectInput(
* have to go to the underlying channel, get more bytes and then
* transform them for delivery. We may not get what we want (full EOF
* or temporarily out of data).
- */
-
- /*
+ *
* Length (rtPtr->result) == 0, toRead > 0 here. Use 'buf'! as target
* to store the intermediary information read from the parent channel.
*
@@ -1088,7 +1102,8 @@ ReflectInput(
if ((rtPtr->methods & FLAG(METH_LIMIT))) {
int maxRead = -1;
- if (!TransformLimit (rtPtr, errorCodePtr, &maxRead)) {
+
+ if (!TransformLimit(rtPtr, errorCodePtr, &maxRead)) {
return -1;
}
if (maxRead == 0) {
@@ -1105,22 +1120,24 @@ ReflectInput(
return gotBytes;
}
- read = Tcl_ReadRaw (rtPtr->parent, buf, toRead);
+ read = Tcl_ReadRaw(rtPtr->parent, buf, toRead);
if (read < 0) {
- /* Report errors to caller.
- * The state of the seek system is unchanged!
+ /*
+ * Report errors to caller. The state of the seek system is
+ * unchanged!
*/
- if ((Tcl_GetErrno () == EAGAIN) && (gotBytes > 0)) {
- /* EAGAIN is a special situation. If we had some data
- * before we report that instead of the request to re-try.
+ if ((Tcl_GetErrno() == EAGAIN) && (gotBytes > 0)) {
+ /*
+ * EAGAIN is a special situation. If we had some data before
+ * we report that instead of the request to re-try.
*/
return gotBytes;
}
- *errorCodePtr = Tcl_GetErrno ();
- return -1;
+ *errorCodePtr = Tcl_GetErrno();
+ return -1;
}
if (read == 0) {
@@ -1134,17 +1151,21 @@ ReflectInput(
* convert and flush all waiting partial data.
*/
- if (!Tcl_Eof (rtPtr->parent)) {
- /* The state of the seek system is unchanged! */
+ if (!Tcl_Eof(rtPtr->parent)) {
+ /*
+ * The state of the seek system is unchanged!
+ */
if ((gotBytes == 0) && rtPtr->nonblocking) {
*errorCodePtr = EWOULDBLOCK;
return -1;
- } else {
- return gotBytes;
}
+ return gotBytes;
} else {
- /* Eof in parent */
+ /*
+ * Eof in parent.
+ */
+
if (rtPtr->readIsDrained) {
return gotBytes;
}
@@ -1155,18 +1176,24 @@ ReflectInput(
*/
if (HAS(rtPtr->methods, METH_DRAIN)) {
- if(!TransformDrain (rtPtr, errorCodePtr)) {
+ if (!TransformDrain(rtPtr, errorCodePtr)) {
return -1;
}
}
- if (ResultLength (&rtPtr->result) == 0) {
- /* The drain delivered nothing */
+ if (ResultLength(&rtPtr->result) == 0) {
+ /*
+ * The drain delivered nothing.
+ */
+
return gotBytes;
}
- /* Reset eof, force caller to drain result buffer */
- ((Channel*) rtPtr->parent)->state->flags &= ~CHANNEL_EOF;
+ /*
+ * Reset eof, force caller to drain result buffer.
+ */
+
+ ((Channel *) rtPtr->parent)->state->flags &= ~CHANNEL_EOF;
continue; /* at: while (toRead > 0) */
}
} /* read == 0 */
@@ -1177,13 +1204,12 @@ ReflectInput(
* iteration will put it into the result.
*/
- if (!TransformRead (rtPtr, errorCodePtr, UCHARP(buf), read)) {
+ if (!TransformRead(rtPtr, errorCodePtr, UCHARP(buf), read)) {
return -1;
}
} /* while toRead > 0 */
return gotBytes;
-
}
/*
@@ -1209,7 +1235,7 @@ ReflectOutput(
int toWrite,
int *errorCodePtr)
{
- ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+ ReflectedTransform *rtPtr = clientData;
/*
* The following check can be done before thread redirection, because we
@@ -1224,8 +1250,10 @@ ReflectOutput(
}
if (toWrite == 0) {
- /* Nothing came in to write, ignore the call
+ /*
+ * Nothing came in to write, ignore the call
*/
+
return 0;
}
@@ -1235,7 +1263,7 @@ ReflectOutput(
*/
if ((rtPtr->methods & FLAG(METH_CLEAR))) {
- TransformClear (rtPtr);
+ TransformClear(rtPtr);
}
/*
@@ -1244,7 +1272,7 @@ ReflectOutput(
* parent channel for further processing.
*/
- if (!TransformWrite (rtPtr, errorCodePtr, UCHARP(buf), toWrite)) {
+ if (!TransformWrite(rtPtr, errorCodePtr, UCHARP(buf), toWrite)) {
return -1;
}
@@ -1263,7 +1291,8 @@ ReflectOutput(
* The new location of the access point.
*
* Side effects:
- * Allocates memory. Arbitrary, per the parent channel, and the called scripts.
+ * Allocates memory. Arbitrary, per the parent channel, and the called
+ * scripts.
*
*----------------------------------------------------------------------
*/
@@ -1275,12 +1304,12 @@ ReflectSeekWide(
int seekMode,
int *errorCodePtr)
{
- ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
- Channel* parent = (Channel*) rtPtr->parent;
+ ReflectedTransform *rtPtr = clientData;
+ Channel *parent = (Channel *) rtPtr->parent;
Tcl_WideInt curPos; /* Position on the device. */
- Tcl_DriverSeekProc *seekProc =
- Tcl_ChannelSeekProc(Tcl_GetChannelType (rtPtr->parent));
+ Tcl_DriverSeekProc *seekProc =
+ Tcl_ChannelSeekProc(Tcl_GetChannelType(rtPtr->parent));
/*
* Fail if the parent channel is not seekable.
@@ -1298,19 +1327,16 @@ ReflectSeekWide(
* request down and the result back up unchanged.
*/
- if (
- ((seekMode != SEEK_CUR) || (offset != 0)) &&
- (HAS(rtPtr->methods, METH_CLEAR) ||
- HAS(rtPtr->methods, METH_FLUSH))
- ) {
+ if (((seekMode != SEEK_CUR) || (offset != 0)) &&
+ (HAS(rtPtr->methods,METH_CLEAR) || HAS(rtPtr->methods,METH_FLUSH))){
/*
- * Neither a tell request, nor clear/flush both not supported. We
- * have to go through the Tcl level to clear and/or flush the
+ * Neither a tell request, nor clear/flush both not supported. We have
+ * to go through the Tcl level to clear and/or flush the
* transformation.
*/
if ((rtPtr->methods & FLAG(METH_CLEAR))) {
- TransformClear (rtPtr);
+ TransformClear(rtPtr);
}
/*
@@ -1321,7 +1347,7 @@ ReflectSeekWide(
*/
if (HAS(rtPtr->methods, METH_FLUSH)) {
- if (!TransformFlush (rtPtr, errorCodePtr, FLUSH_DISCARD)) {
+ if (!TransformFlush(rtPtr, errorCodePtr, FLUSH_DISCARD)) {
return -1;
}
}
@@ -1335,14 +1361,14 @@ ReflectSeekWide(
if (HaveVersion(parent->typePtr, TCL_CHANNEL_VERSION_3) &&
parent->typePtr->wideSeekProc != NULL) {
- curPos = (parent->typePtr->wideSeekProc) (parent->instanceData,
- offset, seekMode, errorCodePtr);
+ curPos = parent->typePtr->wideSeekProc(parent->instanceData, offset,
+ seekMode, errorCodePtr);
} else if (offset < Tcl_LongAsWide(LONG_MIN) ||
offset > Tcl_LongAsWide(LONG_MAX)) {
*errorCodePtr = EOVERFLOW;
curPos = Tcl_LongAsWide(-1);
} else {
- curPos = Tcl_LongAsWide((parent->typePtr->seekProc) (
+ curPos = Tcl_LongAsWide(parent->typePtr->seekProc(
parent->instanceData, Tcl_WideAsLong(offset), seekMode,
errorCodePtr));
}
@@ -1394,12 +1420,11 @@ ReflectWatch(
ClientData clientData,
int mask)
{
- ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
- Tcl_DriverWatchProc* watchProc;
+ ReflectedTransform *rtPtr = clientData;
+ Tcl_DriverWatchProc *watchProc;
- watchProc = Tcl_ChannelWatchProc (Tcl_GetChannelType (rtPtr->parent));
- (*watchProc) (Tcl_GetChannelInstanceData(rtPtr->parent),
- mask);
+ watchProc = Tcl_ChannelWatchProc(Tcl_GetChannelType(rtPtr->parent));
+ watchProc(Tcl_GetChannelInstanceData(rtPtr->parent), mask);
/*
* Management of the internal timer.
@@ -1408,11 +1433,11 @@ ReflectWatch(
if (!(mask & TCL_READABLE) || (ResultLength(&rtPtr->result) == 0)) {
/*
* A pending timer may exist, but either is there no (more) interest
- * in the events it generates or nothing is available for
- * reading. Remove it, if existing.
+ * in the events it generates or nothing is available for reading.
+ * Remove it, if existing.
*/
- TimerKill (rtPtr);
+ TimerKill(rtPtr);
} else {
/*
* There might be no pending timer, but there is interest in readable
@@ -1420,7 +1445,7 @@ ReflectWatch(
* flush that if it does not exist.
*/
- TimerSetup (rtPtr);
+ TimerSetup(rtPtr);
}
}
@@ -1446,7 +1471,7 @@ ReflectBlock(
ClientData clientData,
int nonblocking)
{
- ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+ ReflectedTransform *rtPtr = clientData;
/*
* Transformations simply record the blocking mode in their C level
@@ -1481,7 +1506,7 @@ ReflectSetOption(
const char *optionName, /* Name of requested option */
const char *newValue) /* The new value */
{
- ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+ ReflectedTransform *rtPtr = clientData;
/*
* Transformations have no options. Thus the call is passed down unchanged
@@ -1490,15 +1515,14 @@ ReflectSetOption(
* level is not involved there is no need for thread forwarding.
*/
- Tcl_DriverSetOptionProc *setOptionProc =
- Tcl_ChannelSetOptionProc (Tcl_GetChannelType (rtPtr->parent));
+ Tcl_DriverSetOptionProc *setOptionProc =
+ Tcl_ChannelSetOptionProc(Tcl_GetChannelType(rtPtr->parent));
- if (setOptionProc != NULL) {
- return (*setOptionProc) (Tcl_GetChannelInstanceData (rtPtr->parent),
- interp, optionName, newValue);
- } else {
- return TCL_ERROR;
+ if (setOptionProc == NULL) {
+ return TCL_ERROR;
}
+ return setOptionProc(Tcl_GetChannelInstanceData(rtPtr->parent), interp,
+ optionName, newValue);
}
/*
@@ -1524,7 +1548,7 @@ ReflectGetOption(
const char *optionName, /* Name of reuqested option */
Tcl_DString *dsPtr) /* String to place the result into */
{
- ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+ ReflectedTransform *rtPtr = clientData;
/*
* Transformations have no options. Thus the call is passed down unchanged
@@ -1537,16 +1561,16 @@ ReflectGetOption(
* specific option has to fail.
*/
- Tcl_DriverGetOptionProc *getOptionProc =
- Tcl_ChannelGetOptionProc (Tcl_GetChannelType (rtPtr->parent));
+ Tcl_DriverGetOptionProc *getOptionProc =
+ Tcl_ChannelGetOptionProc(Tcl_GetChannelType(rtPtr->parent));
if (getOptionProc != NULL) {
- return (*getOptionProc) (Tcl_GetChannelInstanceData (rtPtr->parent),
- interp, optionName, dsPtr);
- } else if (optionName == (char*) NULL) {
- return TCL_OK;
+ return getOptionProc(Tcl_GetChannelInstanceData(rtPtr->parent),
+ interp, optionName, dsPtr);
+ } else if (optionName == NULL) {
+ return TCL_OK;
} else {
- return TCL_ERROR;
+ return TCL_ERROR;
}
}
@@ -1568,11 +1592,11 @@ ReflectGetOption(
static int
ReflectHandle(
- ClientData clientData,
- int direction,
- ClientData* handlePtr)
+ ClientData clientData,
+ int direction,
+ ClientData *handlePtr)
{
- ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+ ReflectedTransform *rtPtr = clientData;
/*
* Transformations have no handle of their own. As such we simply query
@@ -1584,7 +1608,7 @@ ReflectHandle(
* involved no forwarding is required.
*/
- return Tcl_GetChannelHandle (rtPtr->parent, direction, handlePtr);
+ return Tcl_GetChannelHandle(rtPtr->parent, direction, handlePtr);
}
/*
*----------------------------------------------------------------------
@@ -1604,10 +1628,10 @@ ReflectHandle(
static int
ReflectNotify(
- ClientData clientData,
- int mask)
+ ClientData clientData,
+ int mask)
{
- ReflectedTransform *rtPtr = (ReflectedTransform *) clientData;
+ ReflectedTransform *rtPtr = clientData;
/*
* An event occured in the underlying channel.
@@ -1618,7 +1642,7 @@ ReflectNotify(
* us to recreate the timer (in ReflectWatch).
*/
- TimerKill (rtPtr);
+ TimerKill(rtPtr);
/*
* Pass to higher layers.
@@ -1722,14 +1746,17 @@ NewReflectedTransform(
rtPtr->interp = interp;
rtPtr->handle = handleObj;
Tcl_IncrRefCount(handleObj);
- rtPtr->timer = (Tcl_TimerToken) NULL;
+ rtPtr->timer = NULL;
rtPtr->mode = 0;
rtPtr->readIsDrained = 0;
- rtPtr->nonblocking =
- (((Channel*) parentChan)->state->flags & CHANNEL_NONBLOCKING);
- /* Query parent for current blocking mode. */
+ rtPtr->nonblocking =
+ (((Channel *) parentChan)->state->flags & CHANNEL_NONBLOCKING);
- ResultInit (&rtPtr->result);
+ /*
+ * Query parent for current blocking mode.
+ */
+
+ ResultInit(&rtPtr->result);
/*
* Method placeholder.
@@ -1750,7 +1777,7 @@ NewReflectedTransform(
*/
rtPtr->argc = listc + 2;
- rtPtr->argv = (Tcl_Obj**) ckalloc(sizeof(Tcl_Obj*) * (listc+4));
+ rtPtr->argv = (Tcl_Obj **) ckalloc(sizeof(Tcl_Obj *) * (listc+4));
/*
* Duplicate object references.
@@ -1758,6 +1785,7 @@ NewReflectedTransform(
for (i=0; i<listc ; i++) {
Tcl_Obj *word = rtPtr->argv[i] = listv[i];
+
Tcl_IncrRefCount(word);
}
@@ -1828,8 +1856,8 @@ FreeReflectedTransform(
{
int i, n;
- TimerKill (rtPtr);
- ResultClear (&rtPtr->result);
+ TimerKill(rtPtr);
+ ResultClear(&rtPtr->result);
Tcl_DecrRefCount(rtPtr->handle);
rtPtr->handle = NULL;
@@ -2039,7 +2067,8 @@ GetReflectedTransformMap(
ReflectedTransformMap *rtmPtr = Tcl_GetAssocData(interp, RTMKEY, NULL);
if (rtmPtr == NULL) {
- rtmPtr = (ReflectedTransformMap *) ckalloc(sizeof(ReflectedTransformMap));
+ rtmPtr = (ReflectedTransformMap *)
+ ckalloc(sizeof(ReflectedTransformMap));
Tcl_InitHashTable(&rtmPtr->map, TCL_STRING_KEYS);
Tcl_SetAssocData(interp, RTMKEY,
(Tcl_InterpDeleteProc *) DeleteReflectedTransformMap, rtmPtr);
@@ -2076,7 +2105,6 @@ DeleteReflectedTransformMap(
Tcl_HashSearch hSearch; /* Search variable. */
Tcl_HashEntry *hPtr; /* Search variable. */
ReflectedTransform *rtPtr;
-
#ifdef TCL_THREADS
ForwardingResult *resultPtr;
ForwardingEvent *evPtr;
@@ -2099,7 +2127,7 @@ DeleteReflectedTransformMap(
for (hPtr = Tcl_FirstHashEntry(&rtmPtr->map, &hSearch);
hPtr != NULL;
hPtr = Tcl_FirstHashEntry(&rtmPtr->map, &hSearch)) {
- rtPtr = (ReflectedTransform *) Tcl_GetHashValue (hPtr);
+ rtPtr = Tcl_GetHashValue(hPtr);
rtPtr->interp = NULL;
Tcl_DeleteHashEntry(hPtr);
}
@@ -2119,8 +2147,7 @@ DeleteReflectedTransformMap(
Tcl_MutexLock(&rtForwardMutex);
- for (resultPtr = forwardList;
- resultPtr != NULL;
+ for (resultPtr = forwardList; resultPtr != NULL;
resultPtr = resultPtr->nextPtr) {
if (resultPtr->dsti != interp) {
/*
@@ -2158,7 +2185,7 @@ DeleteReflectedTransformMap(
for (hPtr = Tcl_FirstHashEntry(&rtmPtr->map, &hSearch);
hPtr != NULL;
hPtr = Tcl_NextHashEntry(&hSearch)) {
- rtPtr = (ReflectedTransform *) Tcl_GetHashValue (hPtr);
+ rtPtr = Tcl_GetHashValue(hPtr);
if (rtPtr->interp != interp) {
/*
@@ -2250,8 +2277,7 @@ DeleteThreadReflectedTransformMap(
Tcl_MutexLock(&rtForwardMutex);
- for (resultPtr = forwardList;
- resultPtr != NULL;
+ for (resultPtr = forwardList; resultPtr != NULL;
resultPtr = resultPtr->nextPtr) {
ForwardingEvent *evPtr;
ForwardParam *paramPtr;
@@ -2291,7 +2317,7 @@ DeleteThreadReflectedTransformMap(
for (hPtr = Tcl_FirstHashEntry(&rtmPtr->map, &hSearch);
hPtr != NULL;
hPtr = Tcl_FirstHashEntry(&rtmPtr->map, &hSearch)) {
- ReflectedTransform *rtPtr = (ReflectedTransform *) Tcl_GetHashValue(hPtr);
+ ReflectedTransform *rtPtr = Tcl_GetHashValue(hPtr);
rtPtr->interp = NULL;
Tcl_DeleteHashEntry(hPtr);
@@ -2304,7 +2330,7 @@ static void
ForwardOpToOwnerThread(
ReflectedTransform *rtPtr, /* Channel instance */
ForwardedOperation op, /* Forwarded driver operation */
- const VOID *param) /* Arguments */
+ const void *param) /* Arguments */
{
Tcl_ThreadId dst = rtPtr->thread;
ForwardingEvent *evPtr;
@@ -2363,13 +2389,13 @@ ForwardOpToOwnerThread(
* (see above) for.
*/
- Tcl_CreateThreadExitHandler(SrcExitProc, (ClientData) evPtr);
+ Tcl_CreateThreadExitHandler(SrcExitProc, evPtr);
/*
* Queue the event and poke the other thread's notifier.
*/
- Tcl_ThreadQueueEvent(dst, (Tcl_Event *)evPtr, TCL_QUEUE_TAIL);
+ Tcl_ThreadQueueEvent(dst, (Tcl_Event *) evPtr, TCL_QUEUE_TAIL);
Tcl_ThreadAlert(dst);
/*
@@ -2411,7 +2437,7 @@ ForwardOpToOwnerThread(
* notifier, after it serviced the event.
*/
- Tcl_DeleteThreadExitHandler(SrcExitProc, (ClientData) evPtr);
+ Tcl_DeleteThreadExitHandler(SrcExitProc, evPtr);
result = resultPtr->result;
ckfree((char*) resultPtr);
@@ -2441,8 +2467,10 @@ ForwardProc(
Tcl_Interp *interp = rtPtr->interp;
ForwardParam *paramPtr = evPtr->param;
Tcl_Obj *resObj = NULL; /* Interp result of InvokeTclMethod */
- ReflectedTransformMap* rtmPtr; /* Map of reflected channels with handlers in this interp */
- Tcl_HashEntry* hPtr; /* Entry in the above map */
+ ReflectedTransformMap *rtmPtr;
+ /* Map of reflected channels with handlers in
+ * this interp. */
+ Tcl_HashEntry *hPtr; /* Entry in the above map */
/*
* Ignore the event if no one is waiting for its result anymore.
@@ -2468,7 +2496,8 @@ ForwardProc(
* No parameters/results.
*/
- if (InvokeTclMethod(rtPtr, "finalize", NULL, NULL, &resObj) != TCL_OK) {
+ if (InvokeTclMethod(rtPtr, "finalize", NULL, NULL,
+ &resObj) != TCL_OK) {
ForwardSetObjError(paramPtr, resObj);
}
@@ -2484,10 +2513,9 @@ ForwardProc(
* dereferencing a dangling pointer.
*/
- rtmPtr = GetReflectedTransformMap (interp);
- hPtr = Tcl_FindHashEntry (&rtmPtr->map,
- Tcl_GetString(rtPtr->handle));
- Tcl_DeleteHashEntry (hPtr);
+ rtmPtr = GetReflectedTransformMap(interp);
+ hPtr = Tcl_FindHashEntry(&rtmPtr->map, Tcl_GetString(rtPtr->handle));
+ Tcl_DeleteHashEntry(hPtr);
/*
* In a threaded interpreter we manage a per-thread map as well, to
@@ -2496,15 +2524,14 @@ ForwardProc(
*/
rtmPtr = GetThreadReflectedTransformMap();
- hPtr = Tcl_FindHashEntry (&rtmPtr->map,
- Tcl_GetString(rtPtr->handle));
- Tcl_DeleteHashEntry (hPtr);
+ hPtr = Tcl_FindHashEntry(&rtmPtr->map, Tcl_GetString(rtPtr->handle));
+ Tcl_DeleteHashEntry(hPtr);
FreeReflectedTransform(rtPtr);
break;
case ForwardedInput: {
- Tcl_Obj *bufObj = Tcl_NewByteArrayObj((unsigned char *) paramPtr->transform.buf,
- paramPtr->transform.size);
+ Tcl_Obj *bufObj = Tcl_NewByteArrayObj((unsigned char *)
+ paramPtr->transform.buf, paramPtr->transform.size);
if (InvokeTclMethod(rtPtr, "read", bufObj, NULL, &resObj) != TCL_OK) {
ForwardSetObjError(paramPtr, resObj);
@@ -2516,14 +2543,15 @@ ForwardProc(
*/
int bytec; /* Number of returned bytes */
- unsigned char *bytev; /* Array of returned bytes */
+ unsigned char *bytev;
+ /* Array of returned bytes */
bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
paramPtr->transform.size = bytec;
if (bytec > 0) {
- paramPtr->transform.buf = ckalloc (bytec);
+ paramPtr->transform.buf = ckalloc(bytec);
memcpy(paramPtr->transform.buf, bytev, (size_t)bytec);
} else {
paramPtr->transform.buf = NULL;
@@ -2533,8 +2561,8 @@ ForwardProc(
}
case ForwardedOutput: {
- Tcl_Obj *bufObj = Tcl_NewByteArrayObj((unsigned char *) paramPtr->transform.buf,
- paramPtr->transform.size);
+ Tcl_Obj *bufObj = Tcl_NewByteArrayObj((unsigned char *)
+ paramPtr->transform.buf, paramPtr->transform.size);
if (InvokeTclMethod(rtPtr, "write", bufObj, NULL, &resObj) != TCL_OK) {
ForwardSetObjError(paramPtr, resObj);
@@ -2546,14 +2574,15 @@ ForwardProc(
*/
int bytec; /* Number of returned bytes */
- unsigned char *bytev; /* Array of returned bytes */
+ unsigned char *bytev;
+ /* Array of returned bytes */
bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
paramPtr->transform.size = bytec;
if (bytec > 0) {
- paramPtr->transform.buf = ckalloc (bytec);
+ paramPtr->transform.buf = ckalloc(bytec);
memcpy(paramPtr->transform.buf, bytev, (size_t)bytec);
} else {
paramPtr->transform.buf = NULL;
@@ -2580,7 +2609,7 @@ ForwardProc(
paramPtr->transform.size = bytec;
if (bytec > 0) {
- paramPtr->transform.buf = ckalloc (bytec);
+ paramPtr->transform.buf = ckalloc(bytec);
memcpy(paramPtr->transform.buf, bytev, (size_t)bytec);
} else {
paramPtr->transform.buf = NULL;
@@ -2600,14 +2629,15 @@ ForwardProc(
*/
int bytec; /* Number of returned bytes */
- unsigned char *bytev; /* Array of returned bytes */
+ unsigned char *bytev;
+ /* Array of returned bytes */
bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
paramPtr->transform.size = bytec;
if (bytec > 0) {
- paramPtr->transform.buf = ckalloc (bytec);
+ paramPtr->transform.buf = ckalloc(bytec);
memcpy(paramPtr->transform.buf, bytev, (size_t)bytec);
} else {
paramPtr->transform.buf = NULL;
@@ -2627,7 +2657,8 @@ ForwardProc(
if (InvokeTclMethod(rtPtr, "limit?", NULL, NULL, &resObj) != TCL_OK) {
ForwardSetObjError(paramPtr, resObj);
paramPtr->limit.max = -1;
- } else if (Tcl_GetIntFromObj(interp, resObj, &paramPtr->limit.max) != TCL_OK) {
+ } else if (Tcl_GetIntFromObj(interp, resObj,
+ &paramPtr->limit.max) != TCL_OK) {
ForwardSetObjError(paramPtr, MarshallError(interp));
paramPtr->limit.max = -1;
}
@@ -2673,7 +2704,7 @@ static void
SrcExitProc(
ClientData clientData)
{
- ForwardingEvent *evPtr = (ForwardingEvent *) clientData;
+ ForwardingEvent *evPtr = clientData;
ForwardingResult *resultPtr;
ForwardParam *paramPtr;
@@ -2734,265 +2765,270 @@ ForwardSetObjError(
/*
*----------------------------------------------------------------------
*
- * TimerKill --
+ * TimerKill --
*
- * Timer management. Removes the internal timer
- * if it exists.
+ * Timer management. Removes the internal timer if it exists.
*
- * Sideeffects:
- * See above.
+ * Side effects:
+ * See above.
*
- * Result:
- * None.
+ * Result:
+ * None.
*
*----------------------------------------------------------------------
*/
static void
-TimerKill (ReflectedTransform* rtPtr)
+TimerKill(
+ ReflectedTransform *rtPtr)
{
- if (rtPtr->timer == (Tcl_TimerToken) NULL) return;
+ if (rtPtr->timer == NULL) {
+ return;
+ }
- /* Delete an existing flush-out timer, prevent it from firing on a
+ /*
+ * Delete an existing flush-out timer, prevent it from firing on a
* removed/dead channel.
*/
- Tcl_DeleteTimerHandler (rtPtr->timer);
- rtPtr->timer = (Tcl_TimerToken) NULL;
+ Tcl_DeleteTimerHandler(rtPtr->timer);
+ rtPtr->timer = NULL;
}
/*
*----------------------------------------------------------------------
*
- * TimerSetup --
+ * TimerSetup --
*
- * Timer management. Creates the internal timer
- * if it does not exist.
+ * Timer management. Creates the internal timer if it does not exist.
*
- * Sideeffects:
- * See above.
+ * Side effects:
+ * See above.
*
- * Result:
- * None.
+ * Result:
+ * None.
*
*----------------------------------------------------------------------
*/
static void
-TimerSetup (ReflectedTransform* rtPtr)
+TimerSetup(
+ ReflectedTransform *rtPtr)
{
- if (rtPtr->timer != (Tcl_TimerToken) NULL) return;
+ if (rtPtr->timer != NULL) {
+ return;
+ }
- rtPtr->timer = Tcl_CreateTimerHandler (FLUSH_DELAY, TimerRun,
- (ClientData) rtPtr);
+ rtPtr->timer = Tcl_CreateTimerHandler(FLUSH_DELAY, TimerRun, rtPtr);
}
/*
*----------------------------------------------------------------------
*
- * TimerRun --
+ * TimerRun --
*
- * Called by the notifier (-> timer) to flush out
- * information waiting in channel buffers.
+ * Called by the notifier (-> timer) to flush out information waiting in
+ * channel buffers.
*
- * Sideeffects:
- * As of 'Tcl_NotifyChannel'.
+ * Side effects:
+ * As of 'Tcl_NotifyChannel'.
*
- * Result:
- * None.
+ * Result:
+ * None.
*
*----------------------------------------------------------------------
*/
static void
-TimerRun (ClientData clientData)
+TimerRun(
+ ClientData clientData)
{
- ReflectedTransform* rtPtr = (ReflectedTransform*) clientData;
+ ReflectedTransform *rtPtr = clientData;
- rtPtr->timer = (Tcl_TimerToken) NULL;
- Tcl_NotifyChannel (rtPtr->chan, TCL_READABLE);
+ rtPtr->timer = NULL;
+ Tcl_NotifyChannel(rtPtr->chan, TCL_READABLE);
}
-
/*
*----------------------------------------------------------------------
*
- * ResultInit --
+ * ResultInit --
*
- * Initializes the specified buffer structure. The
- * structure will contain valid information for an
- * emtpy buffer.
+ * Initializes the specified buffer structure. The structure will contain
+ * valid information for an emtpy buffer.
*
- * Sideeffects:
- * See above.
+ * Side effects:
+ * See above.
*
- * Result:
- * None.
+ * Result:
+ * None.
*
*----------------------------------------------------------------------
*/
static void
-ResultInit (ResultBuffer* r) /* Reference to the structure to initialize */
+ResultInit(
+ ResultBuffer *rPtr) /* Reference to the structure to
+ * initialize. */
{
- r->used = 0;
- r->allocated = 0;
- r->buf = NULL;
+ rPtr->used = 0;
+ rPtr->allocated = 0;
+ rPtr->buf = NULL;
}
/*
*----------------------------------------------------------------------
*
- * ResultClear --
+ * ResultClear --
*
* Deallocates any memory allocated by 'ResultAdd'.
*
- * Sideeffects:
- * See above.
+ * Side effects:
+ * See above.
*
- * Result:
- * None.
+ * Result:
+ * None.
*
*----------------------------------------------------------------------
*/
static void
-ResultClear (ResultBuffer* r) /* Reference to the buffer to clear out */
+ResultClear(
+ ResultBuffer *rPtr) /* Reference to the buffer to clear out */
{
- r->used = 0;
+ rPtr->used = 0;
- if (!r->allocated) return;
+ if (!rPtr->allocated) {
+ return;
+ }
- Tcl_Free ((char*) r->buf);
- r->buf = NULL;
- r->allocated = 0;
+ Tcl_Free((char *) rPtr->buf);
+ rPtr->buf = NULL;
+ rPtr->allocated = 0;
}
/*
*----------------------------------------------------------------------
*
- * ResultAdd --
+ * ResultAdd --
*
- * Adds the bytes in the specified array to the
- * buffer, by appending it.
+ * Adds the bytes in the specified array to the buffer, by appending it.
*
- * Sideeffects:
- * See above.
+ * Side effects:
+ * See above.
*
- * Result:
- * None.
+ * Result:
+ * None.
*
*----------------------------------------------------------------------
*/
static void
-ResultAdd (r, buf, toWrite)
- ResultBuffer* r; /* The buffer to extend */
- unsigned char* buf; /* The buffer to read from */
- int toWrite; /* The number of bytes in 'buf' */
+ResultAdd(
+ ResultBuffer *rPtr, /* The buffer to extend */
+ unsigned char *buf, /* The buffer to read from */
+ int toWrite) /* The number of bytes in 'buf' */
{
- if ((r->used + toWrite + 1) > r->allocated) {
- /* Extension of the internal buffer is required.
+ if ((rPtr->used + toWrite + 1) > rPtr->allocated) {
+ /*
+ * Extension of the internal buffer is required.
* NOTE: Currently linear. Should be doubling to amortize.
*/
- if (r->allocated == 0) {
- r->allocated = toWrite + RB_INCREMENT;
- r->buf = UCHARP(Tcl_Alloc (r->allocated));
+ if (rPtr->allocated == 0) {
+ rPtr->allocated = toWrite + RB_INCREMENT;
+ rPtr->buf = UCHARP(Tcl_Alloc(rPtr->allocated));
} else {
- r->allocated += toWrite + RB_INCREMENT;
- r->buf = UCHARP(Tcl_Realloc((char*) r->buf, r->allocated));
+ rPtr->allocated += toWrite + RB_INCREMENT;
+ rPtr->buf = UCHARP(Tcl_Realloc((char *) rPtr->buf,
+ rPtr->allocated));
}
}
- /* now copy data */
- memcpy (r->buf + r->used, buf, toWrite);
- r->used += toWrite;
+ /*
+ * Now copy data.
+ */
+
+ memcpy(rPtr->buf + rPtr->used, buf, toWrite);
+ rPtr->used += toWrite;
}
/*
*----------------------------------------------------------------------
*
- * ResultCopy --
+ * ResultCopy --
*
- * Copies the requested number of bytes from the
- * buffer into the specified array and removes them
- * from the buffer afterward. Copies less if there
- * is not enough data in the buffer.
+ * Copies the requested number of bytes from the buffer into the
+ * specified array and removes them from the buffer afterward. Copies
+ * less if there is not enough data in the buffer.
*
- * Sideeffects:
- * See above.
+ * Side effects:
+ * See above.
*
- * Result:
- * The number of actually copied bytes,
- * possibly less than 'toRead'.
+ * Result:
+ * The number of actually copied bytes, possibly less than 'toRead'.
*
*----------------------------------------------------------------------
*/
static int
-ResultCopy (ResultBuffer* r, /* The buffer to read from */
- unsigned char* buf, /* The buffer to copy into */
- int toRead) /* Number of requested bytes */
+ResultCopy(
+ ResultBuffer *rPtr, /* The buffer to read from */
+ unsigned char *buf, /* The buffer to copy into */
+ int toRead) /* Number of requested bytes */
{
int copied;
- if (r->used == 0) {
- /* Nothing to copy in the case of an empty buffer.
+ if (rPtr->used == 0) {
+ /*
+ * Nothing to copy in the case of an empty buffer.
*/
copied = 0;
- goto done;
- }
+ } else if (rPtr->used == toRead) {
+ /*
+ * We have just enough. Copy everything to the caller.
+ */
- if (r->used == toRead) {
- /* We have just enough. Copy everything to the caller.
+ memcpy(buf, rPtr->buf, toRead);
+ rPtr->used = 0;
+ copied = toRead;
+ } else if (rPtr->used > toRead) {
+ /*
+ * The internal buffer contains more than requested. Copy the
+ * requested subset to the caller, and shift the remaining bytes down.
*/
- memcpy ((VOID*) buf, (VOID*) r->buf, toRead);
- r->used = 0;
- copied = toRead;
- goto done;
- }
+ memcpy(buf, rPtr->buf, toRead);
+ memmove(rPtr->buf, rPtr->buf + toRead, rPtr->used - toRead);
- if (r->used > toRead) {
- /* The internal buffer contains more than requested.
- * Copy the requested subset to the caller, and shift
- * the remaining bytes down.
+ rPtr->used -= toRead;
+ copied = toRead;
+ } else {
+ /*
+ * There is not enough in the buffer to satisfy the caller, so take
+ * everything.
*/
- memcpy ((VOID*) buf, (VOID*) r->buf, toRead);
- memmove ((VOID*) r->buf, (VOID*) (r->buf + toRead), r->used - toRead);
-
- r->used -= toRead;
- copied = toRead;
- goto done;
+ memcpy(buf, rPtr->buf, rPtr->used);
+ toRead = rPtr->used;
+ rPtr->used = 0;
+ copied = toRead;
}
- /* There is not enough in the buffer to satisfy the caller, so
- * take everything.
- */
-
- memcpy ((VOID*) buf, (VOID*) r->buf, r->used);
- toRead = r->used;
- r->used = 0;
- copied = toRead;
-
/* -- common postwork code ------- */
- done:
return copied;
}
-
static int
-TransformRead (
- ReflectedTransform* rtPtr,
- int* errorCodePtr,
- unsigned char* buf,
- int toRead)
+TransformRead(
+ ReflectedTransform *rtPtr,
+ int *errorCodePtr,
+ unsigned char *buf,
+ int toRead)
{
- Tcl_Obj* bufObj;
- Tcl_Obj* resObj;
+ Tcl_Obj *bufObj;
+ Tcl_Obj *resObj;
int bytec; /* Number of returned bytes */
unsigned char *bytev; /* Array of returned bytes */
@@ -3004,7 +3040,7 @@ TransformRead (
if (rtPtr->thread != Tcl_GetCurrentThread()) {
ForwardParam p;
- p.transform.buf = (char*) buf;
+ p.transform.buf = (char *) buf;
p.transform.size = toRead;
ForwardOpToOwnerThread(rtPtr, ForwardedInput, &p);
@@ -3013,41 +3049,38 @@ TransformRead (
PassReceivedError(rtPtr->chan, &p);
*errorCodePtr = EINVAL;
return 0;
- } else {
- *errorCodePtr = EOK;
}
- ResultAdd (&rtPtr->result, UCHARP(p.transform.buf), p.transform.size);
- ckfree (p.transform.buf);
- } else {
+ *errorCodePtr = EOK;
+ ResultAdd(&rtPtr->result, UCHARP(p.transform.buf), p.transform.size);
+ ckfree(p.transform.buf);
+ return 1;
+ }
#endif
- /* ASSERT: rtPtr->method & FLAG(METH_READ) */
- /* ASSERT: rtPtr->mode & TCL_READABLE */
- bufObj = Tcl_NewByteArrayObj((unsigned char *) buf, toRead);
- if (InvokeTclMethod(rtPtr, "read", bufObj, NULL, &resObj) != TCL_OK) {
- Tcl_SetChannelError(rtPtr->chan, resObj);
- Tcl_DecrRefCount(resObj); /* Remove reference held from invoke */
- *errorCodePtr = EINVAL;
- return 0;
- }
+ /* ASSERT: rtPtr->method & FLAG(METH_READ) */
+ /* ASSERT: rtPtr->mode & TCL_READABLE */
- bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
- ResultAdd (&rtPtr->result, bytev, bytec);
+ bufObj = Tcl_NewByteArrayObj((unsigned char *) buf, toRead);
+ if (InvokeTclMethod(rtPtr, "read", bufObj, NULL, &resObj) != TCL_OK) {
+ Tcl_SetChannelError(rtPtr->chan, resObj);
Tcl_DecrRefCount(resObj); /* Remove reference held from invoke */
-#ifdef TCL_THREADS
+ *errorCodePtr = EINVAL;
+ return 0;
}
-#endif
+ bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
+ ResultAdd(&rtPtr->result, bytev, bytec);
+ Tcl_DecrRefCount(resObj); /* Remove reference held from invoke */
return 1;
}
static int
-TransformWrite (
- ReflectedTransform* rtPtr,
- int* errorCodePtr,
- unsigned char* buf,
- int toWrite)
+TransformWrite(
+ ReflectedTransform *rtPtr,
+ int *errorCodePtr,
+ unsigned char *buf,
+ int toWrite)
{
Tcl_Obj *bufObj;
Tcl_Obj *resObj;
@@ -3063,7 +3096,7 @@ TransformWrite (
if (rtPtr->thread != Tcl_GetCurrentThread()) {
ForwardParam p;
- p.transform.buf = (char*) buf;
+ p.transform.buf = (char *) buf;
p.transform.size = toWrite;
ForwardOpToOwnerThread(rtPtr, ForwardedOutput, &p);
@@ -3072,15 +3105,15 @@ TransformWrite (
PassReceivedError(rtPtr->chan, &p);
*errorCodePtr = EINVAL;
return 0;
- } else {
- *errorCodePtr = EOK;
}
- res = Tcl_WriteRaw (rtPtr->parent,
- (char*) p.transform.buf, p.transform.size);
- ckfree (p.transform.buf);
- } else {
+ *errorCodePtr = EOK;
+ res = Tcl_WriteRaw(rtPtr->parent, (char *) p.transform.buf,
+ p.transform.size);
+ ckfree(p.transform.buf);
+ } else
#endif
+ {
/* ASSERT: rtPtr->method & FLAG(METH_WRITE) */
/* ASSERT: rtPtr->mode & TCL_WRITABLE */
@@ -3095,11 +3128,9 @@ TransformWrite (
*errorCodePtr = EOK;
bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
- res = Tcl_WriteRaw (rtPtr->parent, (char*) bytev, bytec);
- Tcl_DecrRefCount(resObj); /* Remove reference held from invoke */
-#ifdef TCL_THREADS
+ res = Tcl_WriteRaw(rtPtr->parent, (char *) bytev, bytec);
+ Tcl_DecrRefCount(resObj); /* Remove reference held from invoke */
}
-#endif
if (res < 0) {
*errorCodePtr = EINVAL;
@@ -3109,14 +3140,12 @@ TransformWrite (
return 1;
}
-
-
static int
TransformDrain(
- ReflectedTransform* rtPtr,
- int* errorCodePtr)
+ ReflectedTransform *rtPtr,
+ int *errorCodePtr)
{
- Tcl_Obj* resObj;
+ Tcl_Obj *resObj;
int bytec; /* Number of returned bytes */
unsigned char *bytev; /* Array of returned bytes */
@@ -3134,14 +3163,14 @@ TransformDrain(
PassReceivedError(rtPtr->chan, &p);
*errorCodePtr = EINVAL;
return 0;
- } else {
- *errorCodePtr = EOK;
}
- ResultAdd (&rtPtr->result, UCHARP(p.transform.buf), p.transform.size);
- ckfree (p.transform.buf);
- } else {
+ *errorCodePtr = EOK;
+ ResultAdd(&rtPtr->result, UCHARP(p.transform.buf), p.transform.size);
+ ckfree(p.transform.buf);
+ } else
#endif
+ {
if (InvokeTclMethod(rtPtr, "drain", NULL, NULL, &resObj)!=TCL_OK) {
Tcl_SetChannelError(rtPtr->chan, resObj);
Tcl_DecrRefCount(resObj); /* Remove reference held from invoke */
@@ -3150,24 +3179,20 @@ TransformDrain(
}
bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
- ResultAdd (&rtPtr->result, bytev, bytec);
+ ResultAdd(&rtPtr->result, bytev, bytec);
Tcl_DecrRefCount(resObj); /* Remove reference held from invoke */
-
-#ifdef TCL_THREADS
}
-#endif
rtPtr->readIsDrained = 1;
return 1;
}
-
static int
TransformFlush(
- ReflectedTransform* rtPtr,
- int* errorCodePtr,
- int op)
+ ReflectedTransform *rtPtr,
+ int *errorCodePtr,
+ int op)
{
Tcl_Obj* resObj;
int bytec; /* Number of returned bytes */
@@ -3188,19 +3213,19 @@ TransformFlush(
PassReceivedError(rtPtr->chan, &p);
*errorCodePtr = EINVAL;
return 0;
- } else {
- *errorCodePtr = EOK;
}
+ *errorCodePtr = EOK;
if (op == FLUSH_WRITE) {
- res = Tcl_WriteRaw (rtPtr->parent,
- (char*) p.transform.buf, p.transform.size);
+ res = Tcl_WriteRaw(rtPtr->parent, (char *) p.transform.buf,
+ p.transform.size);
} else {
res = 0;
}
ckfree(p.transform.buf);
- } else {
+ } else
#endif
+ {
if (InvokeTclMethod(rtPtr, "flush", NULL, NULL, &resObj)!=TCL_OK) {
Tcl_SetChannelError(rtPtr->chan, resObj);
Tcl_DecrRefCount(resObj); /* Remove reference held from invoke */
@@ -3210,15 +3235,13 @@ TransformFlush(
if (op == FLUSH_WRITE) {
bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
- res = Tcl_WriteRaw (rtPtr->parent, (char*) bytev, bytec);
+ res = Tcl_WriteRaw(rtPtr->parent, (char *) bytev, bytec);
} else {
res = 0;
}
Tcl_DecrRefCount(resObj); /* Remove reference held from invoke */
-
-#ifdef TCL_THREADS
}
-#endif
+
if (res < 0) {
*errorCodePtr = EINVAL;
return 0;
@@ -3228,8 +3251,8 @@ TransformFlush(
}
static void
-TransformClear (
- ReflectedTransform* rtPtr)
+TransformClear(
+ ReflectedTransform *rtPtr)
{
/*
* Are we in the correct thread?
@@ -3241,28 +3264,25 @@ TransformClear (
ForwardOpToOwnerThread(rtPtr, ForwardedClear, &p);
return;
- } else {
+ }
#endif
- /* ASSERT: rtPtr->method & FLAG(METH_READ) */
- /* ASSERT: rtPtr->mode & TCL_READABLE */
- (void) InvokeTclMethod(rtPtr, "clear", NULL, NULL, NULL);
+ /* ASSERT: rtPtr->method & FLAG(METH_READ) */
+ /* ASSERT: rtPtr->mode & TCL_READABLE */
-#ifdef TCL_THREADS
- }
-#endif
+ (void) InvokeTclMethod(rtPtr, "clear", NULL, NULL, NULL);
rtPtr->readIsDrained = 0;
- ResultClear (&rtPtr->result);
+ ResultClear(&rtPtr->result);
}
static int
-TransformLimit (
- ReflectedTransform* rtPtr,
- int* errorCodePtr,
- int* maxPtr)
+TransformLimit(
+ ReflectedTransform *rtPtr,
+ int *errorCodePtr,
+ int *maxPtr)
{
- Tcl_Obj* resObj;
+ Tcl_Obj *resObj;
Tcl_InterpState sr; /* State of handler interp */
/*
@@ -3279,11 +3299,11 @@ TransformLimit (
PassReceivedError(rtPtr->chan, &p);
*errorCodePtr = EINVAL;
return 0;
- } else {
- *errorCodePtr = EOK;
- *maxPtr = p.limit.max;
- return 1;
}
+
+ *errorCodePtr = EOK;
+ *maxPtr = p.limit.max;
+ return 1;
}
#endif
@@ -3337,7 +3357,7 @@ HaveVersion(
{
Tcl_ChannelTypeVersion actualVersion = Tcl_ChannelVersion(chanTypePtr);
- return (PTR2INT(actualVersion)) >= (PTR2INT(minimumVersion));
+ return PTR2INT(actualVersion) >= PTR2INT(minimumVersion);
}
/*