summaryrefslogtreecommitdiffstats
path: root/generic/tclIOGT.c
diff options
context:
space:
mode:
Diffstat (limited to 'generic/tclIOGT.c')
-rw-r--r--generic/tclIOGT.c1153
1 files changed, 576 insertions, 577 deletions
diff --git a/generic/tclIOGT.c b/generic/tclIOGT.c
index 57f9ed2..48419da 100644
--- a/generic/tclIOGT.c
+++ b/generic/tclIOGT.c
@@ -10,104 +10,102 @@
* See the file "license.terms" for information on usage and redistribution
* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
*
- * CVS: $Id: tclIOGT.c,v 1.12 2004/11/13 00:19:09 dgp Exp $
+ * CVS: $Id: tclIOGT.c,v 1.13 2005/07/17 21:17:41 dkf Exp $
*/
#include "tclInt.h"
#include "tclIO.h"
-
/*
- * Forward declarations of internal procedures.
- * First the driver procedures of the transformation.
+ * Forward declarations of internal procedures. First the driver procedures
+ * of the transformation.
*/
-static int TransformBlockModeProc _ANSI_ARGS_ ((
- ClientData instanceData, int mode));
-static int TransformCloseProc _ANSI_ARGS_ ((
- ClientData instanceData, Tcl_Interp* interp));
-static int TransformInputProc _ANSI_ARGS_ ((
- ClientData instanceData,
- char* buf, int toRead, int* errorCodePtr));
-static int TransformOutputProc _ANSI_ARGS_ ((
- ClientData instanceData, CONST char *buf,
- int toWrite, int* errorCodePtr));
-static int TransformSeekProc _ANSI_ARGS_ ((
- ClientData instanceData, long offset,
- int mode, int* errorCodePtr));
+static int TransformBlockModeProc _ANSI_ARGS_((
+ ClientData instanceData, int mode));
+static int TransformCloseProc _ANSI_ARGS_((
+ ClientData instanceData, Tcl_Interp* interp));
+static int TransformInputProc _ANSI_ARGS_((
+ ClientData instanceData, char *buf, int toRead,
+ int *errorCodePtr));
+static int TransformOutputProc _ANSI_ARGS_((
+ ClientData instanceData, CONST char *buf,
+ int toWrite, int *errorCodePtr));
+static int TransformSeekProc _ANSI_ARGS_((
+ ClientData instanceData, long offset, int mode,
+ int *errorCodePtr));
static int TransformSetOptionProc _ANSI_ARGS_((
- ClientData instanceData, Tcl_Interp *interp,
- CONST char *optionName, CONST char *value));
+ ClientData instanceData, Tcl_Interp *interp,
+ CONST char *optionName, CONST char *value));
static int TransformGetOptionProc _ANSI_ARGS_((
- ClientData instanceData, Tcl_Interp *interp,
- CONST char *optionName, Tcl_DString *dsPtr));
-static void TransformWatchProc _ANSI_ARGS_ ((
- ClientData instanceData, int mask));
-static int TransformGetFileHandleProc _ANSI_ARGS_ ((
- ClientData instanceData, int direction,
- ClientData* handlePtr));
-static int TransformNotifyProc _ANSI_ARGS_ ((
- ClientData instanceData, int mask));
-static Tcl_WideInt TransformWideSeekProc _ANSI_ARGS_ ((
- ClientData instanceData, Tcl_WideInt offset,
- int mode, int* errorCodePtr));
+ ClientData instanceData, Tcl_Interp *interp,
+ CONST char *optionName, Tcl_DString *dsPtr));
+static void TransformWatchProc _ANSI_ARGS_((
+ ClientData instanceData, int mask));
+static int TransformGetFileHandleProc _ANSI_ARGS_((
+ ClientData instanceData, int direction,
+ ClientData *handlePtr));
+static int TransformNotifyProc _ANSI_ARGS_((
+ ClientData instanceData, int mask));
+static Tcl_WideInt TransformWideSeekProc _ANSI_ARGS_((
+ ClientData instanceData, Tcl_WideInt offset,
+ int mode, int *errorCodePtr));
/*
- * Forward declarations of internal procedures.
- * Secondly the procedures for handling and generating fileeevents.
+ * Forward declarations of internal procedures. Secondly the procedures for
+ * handling and generating fileeevents.
*/
-static void TransformChannelHandlerTimer _ANSI_ARGS_ ((
- ClientData clientData));
+static void TransformChannelHandlerTimer _ANSI_ARGS_((
+ ClientData clientData));
/*
- * Forward declarations of internal procedures.
- * Third, helper procedures encapsulating essential tasks.
+ * Forward declarations of internal procedures. Third, helper procedures
+ * encapsulating essential tasks.
*/
typedef struct TransformChannelData TransformChannelData;
-static int ExecuteCallback _ANSI_ARGS_ ((
- TransformChannelData* ctrl, Tcl_Interp* interp,
- unsigned char* op, unsigned char* buf,
- int bufLen, int transmit, int preserve));
+static int ExecuteCallback _ANSI_ARGS_((
+ TransformChannelData *ctrl, Tcl_Interp *interp,
+ unsigned char *op, unsigned char *buf, int bufLen,
+ int transmit, int preserve));
/*
- * Action codes to give to 'ExecuteCallback' (argument 'transmit')
- * confering to the procedure what to do with the result of the script
- * it calls.
+ * Action codes to give to 'ExecuteCallback' (argument 'transmit') confering
+ * to the procedure what to do with the result of the script it calls.
*/
-#define TRANSMIT_DONT (0) /* No transfer to do */
-#define TRANSMIT_DOWN (1) /* Transfer to the underlying channel */
-#define TRANSMIT_SELF (2) /* Transfer into our channel. */
-#define TRANSMIT_IBUF (3) /* Transfer to internal input buffer */
-#define TRANSMIT_NUM (4) /* Transfer number to 'maxRead' */
+#define TRANSMIT_DONT (0) /* No transfer to do */
+#define TRANSMIT_DOWN (1) /* Transfer to the underlying channel */
+#define TRANSMIT_SELF (2) /* Transfer into our channel. */
+#define TRANSMIT_IBUF (3) /* Transfer to internal input buffer */
+#define TRANSMIT_NUM (4) /* Transfer number to 'maxRead' */
/*
* Codes for 'preserve' of 'ExecuteCallback'
*/
-#define P_PRESERVE (1)
-#define P_NO_PRESERVE (0)
+#define P_PRESERVE (1)
+#define P_NO_PRESERVE (0)
/*
- * Strings for the action codes delivered to the script implementing
- * a transformation. Argument 'op' of 'ExecuteCallback'.
+ * Strings for the action codes delivered to the script implementing a
+ * transformation. Argument 'op' of 'ExecuteCallback'.
*/
-#define A_CREATE_WRITE (UCHARP ("create/write"))
-#define A_DELETE_WRITE (UCHARP ("delete/write"))
-#define A_FLUSH_WRITE (UCHARP ("flush/write"))
-#define A_WRITE (UCHARP ("write"))
+#define A_CREATE_WRITE (UCHARP("create/write"))
+#define A_DELETE_WRITE (UCHARP("delete/write"))
+#define A_FLUSH_WRITE (UCHARP("flush/write"))
+#define A_WRITE (UCHARP("write"))
-#define A_CREATE_READ (UCHARP ("create/read"))
-#define A_DELETE_READ (UCHARP ("delete/read"))
-#define A_FLUSH_READ (UCHARP ("flush/read"))
-#define A_READ (UCHARP ("read"))
+#define A_CREATE_READ (UCHARP("create/read"))
+#define A_DELETE_READ (UCHARP("delete/read"))
+#define A_FLUSH_READ (UCHARP("flush/read"))
+#define A_READ (UCHARP("read"))
-#define A_QUERY_MAXREAD (UCHARP ("query/maxRead"))
-#define A_CLEAR_READ (UCHARP ("clear/read"))
+#define A_QUERY_MAXREAD (UCHARP("query/maxRead"))
+#define A_CLEAR_READ (UCHARP("clear/read"))
/*
* Management of a simple buffer.
@@ -115,16 +113,16 @@ static int ExecuteCallback _ANSI_ARGS_ ((
typedef struct ResultBuffer ResultBuffer;
-static void ResultClear _ANSI_ARGS_ ((ResultBuffer* r));
-static void ResultInit _ANSI_ARGS_ ((ResultBuffer* r));
-static int ResultLength _ANSI_ARGS_ ((ResultBuffer* r));
-static int ResultCopy _ANSI_ARGS_ ((ResultBuffer* r,
- unsigned char* buf, int toRead));
-static void ResultAdd _ANSI_ARGS_ ((ResultBuffer* r,
- unsigned char* buf, int toWrite));
+static void ResultClear _ANSI_ARGS_((ResultBuffer *r));
+static void ResultInit _ANSI_ARGS_((ResultBuffer *r));
+static int ResultLength _ANSI_ARGS_((ResultBuffer *r));
+static int ResultCopy _ANSI_ARGS_((ResultBuffer *r,
+ unsigned char *buf, int toRead));
+static void ResultAdd _ANSI_ARGS_((ResultBuffer *r,
+ unsigned char *buf, int toWrite));
/*
- * This structure describes the channel type structure for tcl based
+ * This structure describes the channel type structure for Tcl based
* transformations.
*/
@@ -158,30 +156,31 @@ static Tcl_ChannelType transformChannelType = {
*/
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. */
};
/*
* Additional bytes to allocate during buffer expansion
*/
-#define INCREMENT (512)
+#define INCREMENT (512)
/*
- * Number of milliseconds to wait before firing an event to flush
- * out information waiting in buffers (fileevent support).
+ * Number of milliseconds to wait before firing an event to flush out
+ * information waiting in buffers (fileevent support).
*/
-#define FLUSH_DELAY (5)
+#define FLUSH_DELAY (5)
/*
* Convenience macro to make some casts easier to use.
*/
-#define UCHARP(x) ((unsigned char*) (x))
-#define NO_INTERP ((Tcl_Interp*) NULL)
+#define UCHARP(x) ((unsigned char *) (x))
+#define NO_INTERP ((Tcl_Interp *) NULL)
/*
* Definition of a structure used by all transformations generated here to
@@ -189,48 +188,47 @@ struct ResultBuffer {
*/
struct TransformChannelData {
-
/*
* General section. Data to integrate the transformation into the channel
* system.
*/
- Tcl_Channel self; /* Our own Channel handle */
- int readIsFlushed; /* Flag to note wether in.flushProc was called or not
- */
- int flags; /* Currently CHANNEL_ASYNC or zero */
- int watchMask; /* Current watch/event/interest mask */
- int mode; /* mode of parent channel, OR'ed combination of
- * TCL_READABLE, TCL_WRITABLE */
- Tcl_TimerToken timer; /* Timer for automatic flushing of information
- * sitting in an internal buffer. Required for full
- * fileevent support */
+ Tcl_Channel self; /* Our own Channel handle. */
+ int readIsFlushed; /* Flag to note whether in.flushProc was
+ * called or not. */
+ int flags; /* Currently CHANNEL_ASYNC or zero. */
+ int watchMask; /* Current watch/event/interest mask. */
+ int mode; /* Mode of parent channel, OR'ed combination
+ * of TCL_READABLE, TCL_WRITABLE. */
+ Tcl_TimerToken timer; /* Timer for automatic flushing of information
+ * sitting in an internal buffer. Required for
+ * full fileevent support. */
+
/*
* Transformation specific data.
*/
- int maxRead; /* Maximum allowed number of bytes to read, as
- * given to us by the tcl script implementing the
- * transformation. */
- Tcl_Interp* interp; /* Reference to the interpreter which created the
- * transformation. Used to execute the code
- * below. */
- Tcl_Obj* command; /* Tcl code to execute for a buffer */
- ResultBuffer result; /* Internal buffer used to store the result of a
- * transformation of incoming data. Additionally
- * serves as buffer of all data not yet consumed by
- * the reader. */
+ int maxRead; /* Maximum allowed number of bytes to read, as
+ * given to us by the tcl script implementing
+ * the transformation. */
+ Tcl_Interp *interp; /* Reference to the interpreter which created
+ * the transformation. Used to execute the
+ * code below. */
+ Tcl_Obj *command; /* Tcl code to execute for a buffer */
+ ResultBuffer result; /* Internal buffer used to store the result of
+ * a transformation of incoming data.
+ * Additionally serves as buffer of all data
+ * not yet consumed by the reader. */
};
-
/*
*----------------------------------------------------------------------
*
* TclChannelTransform --
*
- * Implements the Tcl "testchannel transform" debugging command.
- * This is part of the testing environment. This sets up a tcl
- * script (cmdObjPtr) to be used as a transform on the channel.
+ * Implements the Tcl "testchannel transform" debugging command. This is
+ * part of the testing environment. This sets up a tcl script (cmdObjPtr)
+ * to be used as a transform on the channel.
*
* Results:
* A standard Tcl result.
@@ -248,30 +246,29 @@ TclChannelTransform(interp, chan, cmdObjPtr)
Tcl_Channel chan; /* Channel to transform. */
Tcl_Obj *cmdObjPtr; /* Script to use for transform. */
{
- Channel *chanPtr; /* The actual channel. */
- ChannelState *statePtr; /* state info for channel */
- int mode; /* rw mode of the channel */
- TransformChannelData *dataPtr;
- int res;
- Tcl_DString ds;
+ Channel *chanPtr; /* The actual channel. */
+ ChannelState *statePtr; /* state info for channel */
+ int mode; /* rw mode of the channel */
+ TransformChannelData *dataPtr;
+ int res;
+ Tcl_DString ds;
if (chan == (Tcl_Channel) NULL) {
return TCL_ERROR;
}
- chanPtr = (Channel *) chan;
- statePtr = chanPtr->state;
- chanPtr = statePtr->topChanPtr;
- chan = (Tcl_Channel) chanPtr;
- mode = (statePtr->flags & (TCL_READABLE|TCL_WRITABLE));
+ chanPtr = (Channel *) chan;
+ statePtr = chanPtr->state;
+ chanPtr = statePtr->topChanPtr;
+ chan = (Tcl_Channel) chanPtr;
+ mode = (statePtr->flags & (TCL_READABLE|TCL_WRITABLE));
/*
- * Now initialize the transformation state and stack it upon the
- * specified channel. One of the necessary things to do is to
- * retrieve the blocking regime of the underlying channel and to
- * use the same for us too.
+ * Now initialize the transformation state and stack it upon the specified
+ * channel. One of the necessary things to do is to retrieve the blocking
+ * regime of the underlying channel and to use the same for us too.
*/
- dataPtr = (TransformChannelData*) ckalloc(sizeof(TransformChannelData));
+ dataPtr = (TransformChannelData *) ckalloc(sizeof(TransformChannelData));
Tcl_DStringInit (&ds);
Tcl_GetChannelOption(interp, chan, "-blocking", &ds);
@@ -283,15 +280,15 @@ TclChannelTransform(interp, chan, cmdObjPtr)
dataPtr->flags |= CHANNEL_ASYNC;
}
- Tcl_DStringFree (&ds);
+ Tcl_DStringFree(&ds);
- dataPtr->self = chan;
- dataPtr->watchMask = 0;
- dataPtr->mode = mode;
- dataPtr->timer = (Tcl_TimerToken) NULL;
- dataPtr->maxRead = 4096; /* Initial value not relevant */
- dataPtr->interp = interp;
- dataPtr->command = cmdObjPtr;
+ dataPtr->self = chan;
+ dataPtr->watchMask = 0;
+ dataPtr->mode = mode;
+ dataPtr->timer = (Tcl_TimerToken) NULL;
+ dataPtr->maxRead = 4096; /* Initial value not relevant */
+ dataPtr->interp = interp;
+ dataPtr->command = cmdObjPtr;
Tcl_IncrRefCount(dataPtr->command);
@@ -305,7 +302,7 @@ TclChannelTransform(interp, chan, cmdObjPtr)
Tcl_DecrRefCount(dataPtr->command);
ResultClear(&dataPtr->result);
- ckfree((VOID *) dataPtr);
+ ckfree((char *) dataPtr);
return TCL_ERROR;
}
@@ -314,8 +311,8 @@ TclChannelTransform(interp, chan, cmdObjPtr)
*/
if (dataPtr->mode & TCL_WRITABLE) {
- res = ExecuteCallback (dataPtr, NO_INTERP, A_CREATE_WRITE,
- NULL, 0, TRANSMIT_DONT, P_NO_PRESERVE);
+ res = ExecuteCallback(dataPtr, NO_INTERP, A_CREATE_WRITE, NULL, 0,
+ TRANSMIT_DONT, P_NO_PRESERVE);
if (res != TCL_OK) {
Tcl_UnstackChannel(interp, chan);
@@ -324,12 +321,12 @@ TclChannelTransform(interp, chan, cmdObjPtr)
}
if (dataPtr->mode & TCL_READABLE) {
- res = ExecuteCallback (dataPtr, NO_INTERP, A_CREATE_READ,
- NULL, 0, TRANSMIT_DONT, P_NO_PRESERVE);
+ res = ExecuteCallback(dataPtr, NO_INTERP, A_CREATE_READ, NULL, 0,
+ TRANSMIT_DONT, P_NO_PRESERVE);
if (res != TCL_OK) {
- ExecuteCallback (dataPtr, NO_INTERP, A_DELETE_WRITE,
- NULL, 0, TRANSMIT_DONT, P_NO_PRESERVE);
+ ExecuteCallback(dataPtr, NO_INTERP, A_DELETE_WRITE, NULL, 0,
+ TRANSMIT_DONT, P_NO_PRESERVE);
Tcl_UnstackChannel(interp, chan);
return TCL_ERROR;
@@ -340,37 +337,36 @@ TclChannelTransform(interp, chan, cmdObjPtr)
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * ExecuteCallback --
+ * ExecuteCallback --
*
- * Executes the defined callback for buffer and
- * operation.
+ * Executes the defined callback for buffer and operation.
*
- * Sideeffects:
- * As of the executed tcl script.
+ * Side effects:
+ * As of the executed tcl script.
*
- * Result:
- * A standard TCL error code. In case of an
- * error a message is left in the result area
- * of the specified interpreter.
+ * Result:
+ * A standard TCL error code. In case of an error a message is left in
+ * the result area of the specified interpreter.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
static int
-ExecuteCallback (dataPtr, interp, op, buf, bufLen, transmit, preserve)
- TransformChannelData* dataPtr; /* Transformation with the callback */
- Tcl_Interp* interp; /* Current interpreter, possibly NULL */
- unsigned char* op; /* Operation invoking the callback */
- unsigned char* buf; /* Buffer to give to the script. */
- int bufLen; /* Ands its length */
- int transmit; /* Flag, determines whether the result
- * of the callback is sent to the
- * underlying channel or not. */
- int preserve; /* Flag. If true the procedure will
- * preserver the result state of all
- * accessed interpreters. */
+ExecuteCallback(dataPtr, interp, op, buf, bufLen, transmit, preserve)
+ TransformChannelData *dataPtr; /* Transformation with the callback */
+ Tcl_Interp *interp; /* Current interpreter, possibly
+ * NULL. */
+ unsigned char *op; /* Operation invoking the callback */
+ unsigned char *buf; /* Buffer to give to the script. */
+ int bufLen; /* And its length */
+ int transmit; /* Flag, determines whether the result
+ * of the callback is sent to the
+ * underlying channel or not. */
+ int preserve; /* Flag. If true the procedure will
+ * preserver the result state of all
+ * accessed interpreters. */
{
/*
* Step 1, create the complete command to execute. Do this by appending
@@ -380,13 +376,13 @@ ExecuteCallback (dataPtr, interp, op, buf, bufLen, transmit, preserve)
* arguments. Feather's curried commands would come in handy here.
*/
- Tcl_Obj* resObj; /* See below, switch (transmit) */
+ Tcl_Obj *resObj; /* See below, switch (transmit) */
int resLen;
- unsigned char* resBuf;
+ unsigned char *resBuf;
Tcl_InterpState state = NULL;
int res = TCL_OK;
- Tcl_Obj* command = Tcl_DuplicateObj (dataPtr->command);
- Tcl_Obj* temp;
+ Tcl_Obj *command = Tcl_DuplicateObj(dataPtr->command);
+ Tcl_Obj *temp;
if (preserve) {
state = Tcl_SaveInterpState(dataPtr->interp, res);
@@ -414,8 +410,8 @@ ExecuteCallback (dataPtr, interp, op, buf, bufLen, transmit, preserve)
}
/*
- * Use a byte-array to prevent the misinterpretation of binary data
- * coming through as UTF while at the tcl level.
+ * Use a byte-array to prevent the misinterpretation of binary data coming
+ * through as UTF while at the tcl level.
*/
temp = Tcl_NewByteArrayObj(buf, bufLen);
@@ -426,21 +422,21 @@ ExecuteCallback (dataPtr, interp, op, buf, bufLen, transmit, preserve)
goto cleanup;
}
- res = Tcl_ListObjAppendElement (dataPtr->interp, command, temp);
+ res = Tcl_ListObjAppendElement(dataPtr->interp, command, temp);
if (res != TCL_OK) {
goto cleanup;
}
/*
- * Step 2, execute the command at the global level of the interpreter
- * used to create the transformation. Destroy the command afterward.
- * If an error occured and the current interpreter is defined and not
- * equal to the interpreter for the callback, then copy the error
- * message into current interpreter. Don't copy if in preservation mode.
+ * Step 2, execute the command at the global level of the interpreter used
+ * to create the transformation. Destroy the command afterward. If an
+ * error occured and the current interpreter is defined and not equal to
+ * the interpreter for the callback, then copy the error message into
+ * current interpreter. Don't copy if in preservation mode.
*/
- res = Tcl_GlobalEvalObj (dataPtr->interp, command);
- Tcl_DecrRefCount (command);
+ res = Tcl_GlobalEvalObj(dataPtr->interp, command);
+ Tcl_DecrRefCount(command);
command = (Tcl_Obj*) NULL;
if ((res != TCL_OK) && (interp != NO_INTERP) &&
@@ -455,34 +451,34 @@ ExecuteCallback (dataPtr, interp, op, buf, bufLen, transmit, preserve)
*/
switch (transmit) {
- case TRANSMIT_DONT:
- /* nothing to do */
- break;
-
- case TRANSMIT_DOWN:
- resObj = Tcl_GetObjResult(dataPtr->interp);
- resBuf = (unsigned char*) Tcl_GetByteArrayFromObj(resObj, &resLen);
- Tcl_WriteRaw(Tcl_GetStackedChannel(dataPtr->self),
- (char*) resBuf, resLen);
- break;
-
- case TRANSMIT_SELF:
- resObj = Tcl_GetObjResult (dataPtr->interp);
- resBuf = (unsigned char*) Tcl_GetByteArrayFromObj(resObj, &resLen);
- Tcl_WriteRaw(dataPtr->self, (char*) resBuf, resLen);
- break;
-
- case TRANSMIT_IBUF:
- resObj = Tcl_GetObjResult (dataPtr->interp);
- resBuf = (unsigned char*) Tcl_GetByteArrayFromObj(resObj, &resLen);
- ResultAdd(&dataPtr->result, resBuf, resLen);
- break;
-
- case TRANSMIT_NUM:
- /* Interpret result as integer number */
- resObj = Tcl_GetObjResult (dataPtr->interp);
- Tcl_GetIntFromObj(dataPtr->interp, resObj, &dataPtr->maxRead);
- break;
+ case TRANSMIT_DONT:
+ /* nothing to do */
+ break;
+
+ case TRANSMIT_DOWN:
+ resObj = Tcl_GetObjResult(dataPtr->interp);
+ resBuf = (unsigned char *) Tcl_GetByteArrayFromObj(resObj, &resLen);
+ Tcl_WriteRaw(Tcl_GetStackedChannel(dataPtr->self), (char *) resBuf,
+ resLen);
+ break;
+
+ case TRANSMIT_SELF:
+ resObj = Tcl_GetObjResult(dataPtr->interp);
+ resBuf = (unsigned char *) Tcl_GetByteArrayFromObj(resObj, &resLen);
+ Tcl_WriteRaw(dataPtr->self, (char *) resBuf, resLen);
+ break;
+
+ case TRANSMIT_IBUF:
+ resObj = Tcl_GetObjResult(dataPtr->interp);
+ resBuf = (unsigned char *) Tcl_GetByteArrayFromObj(resObj, &resLen);
+ ResultAdd(&dataPtr->result, resBuf, resLen);
+ break;
+
+ case TRANSMIT_NUM:
+ /* Interpret result as integer number */
+ resObj = Tcl_GetObjResult(dataPtr->interp);
+ Tcl_GetIntFromObj(dataPtr->interp, resObj, &dataPtr->maxRead);
+ break;
}
Tcl_ResetResult(dataPtr->interp);
@@ -493,7 +489,7 @@ ExecuteCallback (dataPtr, interp, op, buf, bufLen, transmit, preserve)
return res;
- cleanup:
+ cleanup:
if (preserve) {
(void) Tcl_RestoreInterpState(dataPtr->interp, state);
}
@@ -506,30 +502,28 @@ ExecuteCallback (dataPtr, interp, op, buf, bufLen, transmit, preserve)
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * TransformBlockModeProc --
+ * TransformBlockModeProc --
*
- * Trap handler. Called by the generic IO system
- * during option processing to change the blocking
- * mode of the channel.
+ * Trap handler. Called by the generic IO system during option processing
+ * to change the blocking mode of the channel.
*
- * Sideeffects:
- * Forwards the request to the underlying
- * channel.
+ * Side effects:
+ * Forwards the request to the underlying channel.
*
- * Result:
- * 0 if successful, errno when failed.
+ * Result:
+ * 0 if successful, errno when failed.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
static int
-TransformBlockModeProc (instanceData, mode)
- ClientData instanceData; /* State of transformation */
- int mode; /* New blocking mode */
+TransformBlockModeProc(instanceData, mode)
+ ClientData instanceData; /* State of transformation */
+ int mode; /* New blocking mode */
{
- TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
+ TransformChannelData *dataPtr = (TransformChannelData *) instanceData;
if (mode == TCL_MODE_NONBLOCKING) {
dataPtr->flags |= CHANNEL_ASYNC;
@@ -540,33 +534,32 @@ TransformBlockModeProc (instanceData, mode)
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * TransformCloseProc --
+ * TransformCloseProc --
*
- * Trap handler. Called by the generic IO system
- * during destruction of the transformation channel.
+ * Trap handler. Called by the generic IO system during destruction of
+ * the transformation channel.
*
- * Sideeffects:
- * Releases the memory allocated in
- * 'Tcl_TransformObjCmd'.
+ * Side effects:
+ * Releases the memory allocated in 'Tcl_TransformObjCmd'.
*
- * Result:
- * None.
+ * Result:
+ * None.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
static int
-TransformCloseProc (instanceData, interp)
- ClientData instanceData;
- Tcl_Interp* interp;
+TransformCloseProc(instanceData, interp)
+ ClientData instanceData;
+ Tcl_Interp *interp;
{
- TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
+ TransformChannelData *dataPtr = (TransformChannelData *) instanceData;
/*
- * Important: In this procedure 'dataPtr->self' already points to
- * the underlying channel.
+ * Important: In this procedure 'dataPtr->self' already points to the
+ * underlying channel.
*/
/*
@@ -579,36 +572,36 @@ TransformCloseProc (instanceData, interp)
*/
if (dataPtr->timer != (Tcl_TimerToken) NULL) {
- Tcl_DeleteTimerHandler (dataPtr->timer);
+ Tcl_DeleteTimerHandler(dataPtr->timer);
dataPtr->timer = (Tcl_TimerToken) NULL;
}
/*
* Now flush data waiting in internal buffers to output and input. The
- * input must be done despite the fact that there is no real receiver
- * for it anymore. But the scripts might have sideeffects other parts
- * of the system rely on (f.e. signaling the close to interested parties).
+ * input must be done despite the fact that there is no real receiver for
+ * it anymore. But the scripts might have sideeffects other parts of the
+ * system rely on (f.e. signaling the close to interested parties).
*/
if (dataPtr->mode & TCL_WRITABLE) {
- ExecuteCallback (dataPtr, interp, A_FLUSH_WRITE,
- NULL, 0, TRANSMIT_DOWN, 1);
+ ExecuteCallback(dataPtr, interp, A_FLUSH_WRITE, NULL, 0,
+ TRANSMIT_DOWN, 1);
}
if ((dataPtr->mode & TCL_READABLE) && !dataPtr->readIsFlushed) {
dataPtr->readIsFlushed = 1;
- ExecuteCallback (dataPtr, interp, A_FLUSH_READ,
- NULL, 0, TRANSMIT_IBUF, 1);
+ ExecuteCallback(dataPtr, interp, A_FLUSH_READ, NULL, 0,
+ TRANSMIT_IBUF, 1);
}
if (dataPtr->mode & TCL_WRITABLE) {
- ExecuteCallback (dataPtr, interp, A_DELETE_WRITE,
- NULL, 0, TRANSMIT_DONT, 1);
+ ExecuteCallback(dataPtr, interp, A_DELETE_WRITE, NULL, 0,
+ TRANSMIT_DONT, 1);
}
if (dataPtr->mode & TCL_READABLE) {
- ExecuteCallback (dataPtr, interp, A_DELETE_READ,
- NULL, 0, TRANSMIT_DONT, 1);
+ ExecuteCallback(dataPtr, interp, A_DELETE_READ, NULL, 0,
+ TRANSMIT_DONT, 1);
}
/*
@@ -617,42 +610,43 @@ TransformCloseProc (instanceData, interp)
ResultClear(&dataPtr->result);
Tcl_DecrRefCount(dataPtr->command);
- ckfree((VOID*) dataPtr);
+ ckfree((char *) dataPtr);
return TCL_OK;
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * TransformInputProc --
+ * TransformInputProc --
*
* Called by the generic IO system to convert read data.
*
- * Sideeffects:
- * As defined by the conversion.
+ * Side effects:
+ * As defined by the conversion.
*
- * Result:
- * A transformed buffer.
+ * Result:
+ * A transformed buffer.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
static int
-TransformInputProc (instanceData, buf, toRead, errorCodePtr)
+TransformInputProc(instanceData, buf, toRead, errorCodePtr)
ClientData instanceData;
- char* buf;
- int toRead;
- int* errorCodePtr;
+ char *buf;
+ int toRead;
+ int *errorCodePtr;
{
- TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
+ TransformChannelData* dataPtr = (TransformChannelData *) instanceData;
int gotBytes, read, res, copied;
Tcl_Channel downChan;
/* should assert (dataPtr->mode & TCL_READABLE) */
if (toRead == 0) {
- /* Catch a no-op.
+ /*
+ * Catch a no-op.
*/
return 0;
}
@@ -666,33 +660,34 @@ TransformInputProc (instanceData, buf, toRead, errorCodePtr)
* below, possibly EOF).
*/
- copied = ResultCopy (&dataPtr->result, UCHARP (buf), toRead);
+ copied = ResultCopy(&dataPtr->result, UCHARP(buf), toRead);
- toRead -= copied;
- buf += copied;
+ toRead -= copied;
+ buf += copied;
gotBytes += copied;
if (toRead == 0) {
- /* The request was completely satisfied from our buffers.
- * We can break out of the loop and return to the caller.
+ /*
+ * The request was completely satisfied from our buffers. We can
+ * break out of the loop and return to the caller.
*/
return gotBytes;
}
/*
- * Length (dataPtr->result) == 0, toRead > 0 here . Use the incoming
- * 'buf'! as target to store the intermediary information read
- * from the underlying channel.
+ * Length (dataPtr->result) == 0, toRead > 0 here. Use the incoming
+ * 'buf'! as target to store the intermediary information read from
+ * the underlying channel.
*
- * Ask the tcl level how much data it allows us to read from
- * the underlying channel. This feature allows the transform to
- * signal EOF upstream although there is none downstream. Useful
- * to control an unbounded 'fcopy', either through counting bytes,
- * or by pattern matching.
+ * Ask the tcl level how much data it allows us to read from the
+ * underlying channel. This feature allows the transform to signal EOF
+ * upstream although there is none downstream. Useful to control an
+ * unbounded 'fcopy', either through counting bytes, or by pattern
+ * matching.
*/
- ExecuteCallback (dataPtr, NO_INTERP, A_QUERY_MAXREAD,
- NULL, 0, TRANSMIT_NUM /* -> maxRead */, 1);
+ ExecuteCallback(dataPtr, NO_INTERP, A_QUERY_MAXREAD, NULL, 0,
+ TRANSMIT_NUM /* -> maxRead */, 1);
if (dataPtr->maxRead >= 0) {
if (dataPtr->maxRead < toRead) {
@@ -707,9 +702,10 @@ TransformInputProc (instanceData, buf, toRead, errorCodePtr)
read = Tcl_ReadRaw(downChan, buf, toRead);
if (read < 0) {
- /* Report errors to caller. EAGAIN is a special situation.
- * If we had some data before we report that instead of the
- * request to re-try.
+ /*
+ * Report errors to caller. 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)) {
@@ -722,17 +718,16 @@ TransformInputProc (instanceData, buf, toRead, errorCodePtr)
if (read == 0) {
/*
- * Check wether we hit on EOF in the underlying channel or
- * not. If not differentiate between blocking and
- * non-blocking modes. In non-blocking mode we ran
- * temporarily out of data. Signal this to the caller via
- * EWOULDBLOCK and error return (-1). In the other cases
- * we simply return what we got and let the caller wait
- * for more. On the other hand, if we got an EOF we have
- * to convert and flush all waiting partial data.
+ * Check wether we hit on EOF in the underlying channel or not. If
+ * not differentiate between blocking and non-blocking modes. In
+ * non-blocking mode we ran temporarily out of data. Signal this
+ * to the caller via EWOULDBLOCK and error return (-1). In the
+ * other cases we simply return what we got and let the caller
+ * wait for more. On the other hand, if we got an EOF we have to
+ * convert and flush all waiting partial data.
*/
- if (! Tcl_Eof (downChan)) {
+ if (! Tcl_Eof(downChan)) {
if ((gotBytes == 0) && (dataPtr->flags & CHANNEL_ASYNC)) {
*errorCodePtr = EWOULDBLOCK;
return -1;
@@ -741,17 +736,18 @@ TransformInputProc (instanceData, buf, toRead, errorCodePtr)
}
} else {
if (dataPtr->readIsFlushed) {
- /* Already flushed, nothing to do anymore
+ /*
+ * Already flushed, nothing to do anymore.
*/
return gotBytes;
}
dataPtr->readIsFlushed = 1;
- ExecuteCallback (dataPtr, NO_INTERP, A_FLUSH_READ,
- NULL, 0, TRANSMIT_IBUF, P_PRESERVE);
+ ExecuteCallback(dataPtr, NO_INTERP, A_FLUSH_READ, NULL, 0,
+ TRANSMIT_IBUF, P_PRESERVE);
- if (ResultLength (&dataPtr->result) == 0) {
+ if (ResultLength(&dataPtr->result) == 0) {
/* we had nothing to flush */
return gotBytes;
}
@@ -760,12 +756,13 @@ TransformInputProc (instanceData, buf, toRead, errorCodePtr)
}
} /* read == 0 */
- /* Transform the read chunk and add the result to our
- * read buffer (dataPtr->result)
+ /*
+ * Transform the read chunk and add the result to our read buffer
+ * (dataPtr->result)
*/
- res = ExecuteCallback (dataPtr, NO_INTERP, A_READ,
- UCHARP (buf), read, TRANSMIT_IBUF, P_PRESERVE);
+ res = ExecuteCallback(dataPtr, NO_INTERP, A_READ, UCHARP(buf), read,
+ TRANSMIT_IBUF, P_PRESERVE);
if (res != TCL_OK) {
*errorCodePtr = EINVAL;
@@ -777,28 +774,27 @@ TransformInputProc (instanceData, buf, toRead, errorCodePtr)
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * TransformOutputProc --
+ * TransformOutputProc --
*
- * Called by the generic IO system to convert data
- * waiting to be written.
+ * Called by the generic IO system to convert data waiting to be written.
*
- * Sideeffects:
- * As defined by the transformation.
+ * Side effects:
+ * As defined by the transformation.
*
- * Result:
- * A transformed buffer.
+ * Result:
+ * A transformed buffer.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
static int
-TransformOutputProc (instanceData, buf, toWrite, errorCodePtr)
+TransformOutputProc(instanceData, buf, toWrite, errorCodePtr)
ClientData instanceData;
- CONST char* buf;
- int toWrite;
- int* errorCodePtr;
+ CONST char *buf;
+ int toWrite;
+ int *errorCodePtr;
{
TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
int res;
@@ -806,13 +802,13 @@ TransformOutputProc (instanceData, buf, toWrite, errorCodePtr)
/* should assert (dataPtr->mode & TCL_WRITABLE) */
if (toWrite == 0) {
- /* Catch a no-op.
+ /*
+ * Catch a no-op.
*/
return 0;
}
- res = ExecuteCallback (dataPtr, NO_INTERP, A_WRITE,
- UCHARP (buf), toWrite,
+ res = ExecuteCallback(dataPtr, NO_INTERP, A_WRITE, UCHARP(buf), toWrite,
TRANSMIT_DOWN, P_NO_PRESERVE);
if (res != TCL_OK) {
@@ -824,42 +820,40 @@ TransformOutputProc (instanceData, buf, toWrite, errorCodePtr)
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * TransformSeekProc --
+ * TransformSeekProc --
*
- * This procedure is called by the generic IO level
- * to move the access point in a channel.
+ * This procedure is called by the generic IO level to move the access
+ * point in a channel.
*
- * Sideeffects:
- * Moves the location at which the channel
- * will be accessed in future operations.
- * Flushes all transformation buffers, then
- * forwards it to the underlying channel.
+ * Side effects:
+ * Moves the location at which the channel will be accessed in future
+ * operations. Flushes all transformation buffers, then forwards it to
+ * the underlying channel.
*
- * Result:
- * -1 if failed, the new position if
- * successful. An output argument contains
- * the POSIX error code if an error
- * occurred, or zero.
+ * Result:
+ * -1 if failed, the new position if successful. An output argument
+ * contains the POSIX error code if an error occurred, or zero.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
static int
-TransformSeekProc (instanceData, offset, mode, errorCodePtr)
- ClientData instanceData; /* The channel to manipulate */
- long offset; /* Size of movement. */
- int mode; /* How to move */
- int* errorCodePtr; /* Location of error flag. */
+TransformSeekProc(instanceData, offset, mode, errorCodePtr)
+ ClientData instanceData; /* The channel to manipulate */
+ long offset; /* Size of movement. */
+ int mode; /* How to move */
+ int *errorCodePtr; /* Location of error flag. */
{
- TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
- Tcl_Channel parent = Tcl_GetStackedChannel(dataPtr->self);
- Tcl_ChannelType* parentType = Tcl_GetChannelType(parent);
- Tcl_DriverSeekProc* parentSeekProc = Tcl_ChannelSeekProc(parentType);
+ TransformChannelData *dataPtr = (TransformChannelData *) instanceData;
+ Tcl_Channel parent = Tcl_GetStackedChannel(dataPtr->self);
+ Tcl_ChannelType *parentType = Tcl_GetChannelType(parent);
+ Tcl_DriverSeekProc *parentSeekProc = Tcl_ChannelSeekProc(parentType);
if ((offset == 0) && (mode == SEEK_CUR)) {
- /* This is no seek but a request to tell the caller the current
+ /*
+ * This is no seek but a request to tell the caller the current
* location. Simply pass the request down.
*/
@@ -868,19 +862,19 @@ TransformSeekProc (instanceData, offset, mode, errorCodePtr)
}
/*
- * It is a real request to change the position. Flush all data waiting
- * for output and discard everything in the input buffers. Then pass
- * the request down, unchanged.
+ * It is a real request to change the position. Flush all data waiting for
+ * output and discard everything in the input buffers. Then pass the
+ * request down, unchanged.
*/
if (dataPtr->mode & TCL_WRITABLE) {
- ExecuteCallback (dataPtr, NO_INTERP, A_FLUSH_WRITE,
- NULL, 0, TRANSMIT_DOWN, P_NO_PRESERVE);
+ ExecuteCallback(dataPtr, NO_INTERP, A_FLUSH_WRITE, NULL, 0,
+ TRANSMIT_DOWN, P_NO_PRESERVE);
}
if (dataPtr->mode & TCL_READABLE) {
- ExecuteCallback (dataPtr, NO_INTERP, A_CLEAR_READ,
- NULL, 0, TRANSMIT_DONT, P_NO_PRESERVE);
+ ExecuteCallback(dataPtr, NO_INTERP, A_CLEAR_READ, NULL, 0,
+ TRANSMIT_DONT, P_NO_PRESERVE);
ResultClear(&dataPtr->result);
dataPtr->readIsFlushed = 0;
}
@@ -894,41 +888,35 @@ TransformSeekProc (instanceData, offset, mode, errorCodePtr)
*
* TransformWideSeekProc --
*
- * This procedure is called by the generic IO level to move the
- * access point in a channel, with a (potentially) 64-bit offset.
+ * This procedure is called by the generic IO level to move the access
+ * point in a channel, with a (potentially) 64-bit offset.
*
* Side effects:
- * Moves the location at which the channel will be accessed in
- * future operations. Flushes all transformation buffers, then
- * forwards it to the underlying channel.
+ * Moves the location at which the channel will be accessed in future
+ * operations. Flushes all transformation buffers, then forwards it to
+ * the underlying channel.
*
* Result:
- * -1 if failed, the new position if successful. An output
- * argument contains the POSIX error code if an error occurred,
- * or zero.
+ * -1 if failed, the new position if successful. An output argument
+ * contains the POSIX error code if an error occurred, or zero.
*
*----------------------------------------------------------------------
*/
static Tcl_WideInt
-TransformWideSeekProc (instanceData, offset, mode, errorCodePtr)
- ClientData instanceData; /* The channel to manipulate */
+TransformWideSeekProc(instanceData, offset, mode, errorCodePtr)
+ ClientData instanceData; /* The channel to manipulate */
Tcl_WideInt offset; /* Size of movement. */
- int mode; /* How to move */
- int* errorCodePtr; /* Location of error flag. */
+ int mode; /* How to move */
+ int *errorCodePtr; /* Location of error flag. */
{
- TransformChannelData* dataPtr =
- (TransformChannelData*) instanceData;
- Tcl_Channel parent =
- Tcl_GetStackedChannel(dataPtr->self);
- Tcl_ChannelType* parentType =
- Tcl_GetChannelType(parent);
- Tcl_DriverSeekProc* parentSeekProc =
- Tcl_ChannelSeekProc(parentType);
+ TransformChannelData * dataPtr = (TransformChannelData *) instanceData;
+ Tcl_Channel parent = Tcl_GetStackedChannel(dataPtr->self);
+ Tcl_ChannelType* parentType = Tcl_GetChannelType(parent);
+ Tcl_DriverSeekProc* parentSeekProc = Tcl_ChannelSeekProc(parentType);
Tcl_DriverWideSeekProc* parentWideSeekProc =
- Tcl_ChannelWideSeekProc(parentType);
- ClientData parentData =
- Tcl_GetChannelInstanceData(parent);
+ Tcl_ChannelWideSeekProc(parentType);
+ ClientData parentData = Tcl_GetChannelInstanceData(parent);
if ((offset == Tcl_LongAsWide(0)) && (mode == SEEK_CUR)) {
/*
@@ -946,19 +934,19 @@ TransformWideSeekProc (instanceData, offset, mode, errorCodePtr)
}
/*
- * It is a real request to change the position. Flush all data waiting
- * for output and discard everything in the input buffers. Then pass
- * the request down, unchanged.
+ * It is a real request to change the position. Flush all data waiting for
+ * output and discard everything in the input buffers. Then pass the
+ * request down, unchanged.
*/
if (dataPtr->mode & TCL_WRITABLE) {
- ExecuteCallback (dataPtr, NO_INTERP, A_FLUSH_WRITE,
- NULL, 0, TRANSMIT_DOWN, P_NO_PRESERVE);
+ ExecuteCallback(dataPtr, NO_INTERP, A_FLUSH_WRITE, NULL, 0,
+ TRANSMIT_DOWN, P_NO_PRESERVE);
}
if (dataPtr->mode & TCL_READABLE) {
- ExecuteCallback (dataPtr, NO_INTERP, A_CLEAR_READ,
- NULL, 0, TRANSMIT_DONT, P_NO_PRESERVE);
+ ExecuteCallback(dataPtr, NO_INTERP, A_CLEAR_READ, NULL, 0,
+ TRANSMIT_DONT, P_NO_PRESERVE);
ResultClear(&dataPtr->result);
dataPtr->readIsFlushed = 0;
}
@@ -966,46 +954,48 @@ TransformWideSeekProc (instanceData, offset, mode, errorCodePtr)
/*
* If we have a wide seek capability, we should stick with that.
*/
+
if (parentWideSeekProc != NULL) {
return (*parentWideSeekProc) (parentData, offset, mode, errorCodePtr);
}
/*
- * We're transferring to narrow seeks at this point; this is a bit
- * complex because we have to check whether the seek is possible
- * first (i.e. whether we are losing information in truncating the
- * bits of the offset.) Luckily, there's a defined error for what
- * happens when trying to go out of the representable range.
+ * We're transferring to narrow seeks at this point; this is a bit complex
+ * because we have to check whether the seek is possible first (i.e.
+ * whether we are losing information in truncating the bits of the
+ * offset.) Luckily, there's a defined error for what happens when trying
+ * to go out of the representable range.
*/
+
if (offset<Tcl_LongAsWide(LONG_MIN) || offset>Tcl_LongAsWide(LONG_MAX)) {
*errorCodePtr = EOVERFLOW;
return Tcl_LongAsWide(-1);
}
+
return Tcl_LongAsWide((*parentSeekProc) (parentData,
Tcl_WideAsLong(offset), mode, errorCodePtr));
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * TransformSetOptionProc --
+ * TransformSetOptionProc --
*
- * Called by generic layer to handle the reconfi-
- * guration of channel specific options. As this
- * channel type does not have such, it simply passes
- * all requests downstream.
+ * Called by generic layer to handle the reconfiguration of channel
+ * specific options. As this channel type does not have such, it simply
+ * passes all requests downstream.
*
- * Sideeffects:
- * As defined by the channel downstream.
+ * Side effects:
+ * As defined by the channel downstream.
*
- * Result:
- * A standard TCL error code.
+ * Result:
+ * A standard TCL error code.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
static int
-TransformSetOptionProc (instanceData, interp, optionName, value)
+TransformSetOptionProc(instanceData, interp, optionName, value)
ClientData instanceData;
Tcl_Interp *interp;
CONST char *optionName;
@@ -1024,30 +1014,29 @@ TransformSetOptionProc (instanceData, interp, optionName, value)
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * TransformGetOptionProc --
+ * TransformGetOptionProc --
*
- * Called by generic layer to handle requests for
- * the values of channel specific options. As this
- * channel type does not have such, it simply passes
- * all requests downstream.
+ * Called by generic layer to handle requests for the values of channel
+ * specific options. As this channel type does not have such, it simply
+ * passes all requests downstream.
*
- * Sideeffects:
- * As defined by the channel downstream.
+ * Side effects:
+ * As defined by the channel downstream.
*
- * Result:
- * A standard TCL error code.
+ * Result:
+ * A standard TCL error code.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
static int
-TransformGetOptionProc (instanceData, interp, optionName, dsPtr)
- ClientData instanceData;
- Tcl_Interp* interp;
- CONST char* optionName;
- Tcl_DString* dsPtr;
+TransformGetOptionProc(instanceData, interp, optionName, dsPtr)
+ ClientData instanceData;
+ Tcl_Interp *interp;
+ CONST char *optionName;
+ Tcl_DString *dsPtr;
{
TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
Tcl_Channel downChan = Tcl_GetStackedChannel(dataPtr->self);
@@ -1061,165 +1050,166 @@ TransformGetOptionProc (instanceData, interp, optionName, dsPtr)
/*
* Request is query for all options, this is ok.
*/
+
return TCL_OK;
}
+
/*
* Request for a specific option has to fail, we don't have any.
*/
+
return TCL_ERROR;
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * TransformWatchProc --
+ * TransformWatchProc --
*
- * Initialize the notifier to watch for events from
- * this channel.
+ * Initialize the notifier to watch for events from this channel.
*
- * Sideeffects:
- * Sets up the notifier so that a future
- * event on the channel will be seen by Tcl.
+ * Side effects:
+ * Sets up the notifier so that a future event on the channel will be
+ * seen by Tcl.
*
- * Result:
- * None.
+ * Result:
+ * None.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
+
/* ARGSUSED */
static void
-TransformWatchProc (instanceData, mask)
+TransformWatchProc(instanceData, mask)
ClientData instanceData; /* Channel to watch */
- int mask; /* Events of interest */
+ int mask; /* Events of interest */
{
- /* The caller expressed interest in events occuring for this
- * channel. We are forwarding the call to the underlying
- * channel now.
+ /*
+ * The caller expressed interest in events occuring for this channel. We
+ * are forwarding the call to the underlying channel now.
*/
- TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
- Tcl_Channel downChan;
+ TransformChannelData *dataPtr = (TransformChannelData *) instanceData;
+ Tcl_Channel downChan;
dataPtr->watchMask = mask;
- /* No channel handlers any more. We will be notified automatically
- * about events on the channel below via a call to our
- * 'TransformNotifyProc'. But we have to pass the interest down now.
- * We are allowed to add additional 'interest' to the mask if we want
- * to. But this transformation has no such interest. It just passes
- * the request down, unchanged.
+ /*
+ * No channel handlers any more. We will be notified automatically about
+ * events on the channel below via a call to our 'TransformNotifyProc'.
+ * But we have to pass the interest down now. We are allowed to add
+ * additional 'interest' to the mask if we want to. But this
+ * transformation has no such interest. It just passes the request down,
+ * unchanged.
*/
downChan = Tcl_GetStackedChannel(dataPtr->self);
- (Tcl_GetChannelType(downChan))
- ->watchProc(Tcl_GetChannelInstanceData(downChan), mask);
+ Tcl_GetChannelType(downChan)->watchProc(
+ Tcl_GetChannelInstanceData(downChan), mask);
/*
* Management of the internal timer.
*/
if ((dataPtr->timer != (Tcl_TimerToken) NULL) &&
- (!(mask & TCL_READABLE) || (ResultLength(&dataPtr->result) == 0))) {
-
- /* A pending timer exists, but either is there no (more)
- * interest in the events it generates or nothing is availablee
- * for reading, so remove it.
+ (!(mask & TCL_READABLE) || ResultLength(&dataPtr->result)==0)) {
+ /*
+ * A pending timer exists, but either is there no (more) interest in
+ * the events it generates or nothing is availablee for reading, so
+ * remove it.
*/
- Tcl_DeleteTimerHandler (dataPtr->timer);
+ Tcl_DeleteTimerHandler(dataPtr->timer);
dataPtr->timer = (Tcl_TimerToken) NULL;
}
if ((dataPtr->timer == (Tcl_TimerToken) NULL) &&
- (mask & TCL_READABLE) && (ResultLength (&dataPtr->result) > 0)) {
-
- /* There is no pending timer, but there is interest in readable
- * events and we actually have data waiting, so generate a timer
- * to flush that.
+ (mask & TCL_READABLE) && (ResultLength(&dataPtr->result) > 0)) {
+ /*
+ * There is no pending timer, but there is interest in readable events
+ * and we actually have data waiting, so generate a timer to flush
+ * that.
*/
- dataPtr->timer = Tcl_CreateTimerHandler (FLUSH_DELAY,
+ dataPtr->timer = Tcl_CreateTimerHandler(FLUSH_DELAY,
TransformChannelHandlerTimer, (ClientData) dataPtr);
}
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * TransformGetFileHandleProc --
+ * TransformGetFileHandleProc --
*
- * Called from Tcl_GetChannelHandle to retrieve
- * OS specific file handle from inside this channel.
+ * Called from Tcl_GetChannelHandle to retrieve OS specific file handle
+ * from inside this channel.
*
- * Sideeffects:
- * None.
+ * Side effects:
+ * None.
*
- * Result:
- * The appropriate Tcl_File or NULL if not
- * present.
+ * Result:
+ * The appropriate Tcl_File or NULL if not present.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
+
static int
-TransformGetFileHandleProc (instanceData, direction, handlePtr)
- ClientData instanceData; /* Channel to query */
- int direction; /* Direction of interest */
- ClientData* handlePtr; /* Place to store the handle into */
+TransformGetFileHandleProc(instanceData, direction, handlePtr)
+ ClientData instanceData; /* Channel to query */
+ int direction; /* Direction of interest */
+ ClientData *handlePtr; /* Place to store the handle into */
{
/*
- * Return the handle belonging to parent channel.
- * IOW, pass the request down and the result up.
+ * Return the handle belonging to parent channel. IOW, pass the request
+ * down and the result up.
*/
- TransformChannelData* dataPtr = (TransformChannelData*) instanceData;
+ TransformChannelData *dataPtr = (TransformChannelData *) instanceData;
return Tcl_GetChannelHandle(Tcl_GetStackedChannel(dataPtr->self),
direction, handlePtr);
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * TransformNotifyProc --
+ * TransformNotifyProc --
*
- * ------------------------------------------------*
- * Handler called by Tcl to inform us of activity
- * on the underlying channel.
- * ------------------------------------------------*
+ * Handler called by Tcl to inform us of activity on the underlying
+ * channel.
*
- * Sideeffects:
- * May process the incoming event by itself.
+ * Side effects:
+ * May process the incoming event by itself.
*
- * Result:
- * None.
+ * Result:
+ * None.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
static int
-TransformNotifyProc (clientData, mask)
- ClientData clientData; /* The state of the notified transformation */
- int mask; /* The mask of occuring events */
+TransformNotifyProc(clientData, mask)
+ ClientData clientData; /* The state of the notified transformation */
+ int mask; /* The mask of occuring events */
{
- TransformChannelData* dataPtr = (TransformChannelData*) clientData;
+ TransformChannelData *dataPtr = (TransformChannelData *) clientData;
/*
- * An event occured in the underlying channel. This
- * transformation doesn't process such events thus returns the
- * incoming mask unchanged.
+ * An event occured in the underlying channel. This transformation
+ * doesn't process such events thus returns the incoming mask unchanged.
*/
if (dataPtr->timer != (Tcl_TimerToken) NULL) {
/*
- * Delete an existing timer. It was not fired, yet we are
- * here, so the channel below generated such an event and we
- * don't have to. The renewal of the interest after the
- * execution of channel handlers will eventually cause us to
- * recreate the timer (in TransformWatchProc).
+ * Delete an existing timer. It was not fired, yet we are here, so the
+ * channel below generated such an event and we don't have to. The
+ * renewal of the interest after the execution of channel handlers
+ * will eventually cause us to recreate the timer (in
+ * TransformWatchProc).
*/
- Tcl_DeleteTimerHandler (dataPtr->timer);
+ Tcl_DeleteTimerHandler(dataPtr->timer);
dataPtr->timer = (Tcl_TimerToken) NULL;
}
@@ -1227,35 +1217,36 @@ TransformNotifyProc (clientData, mask)
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * TransformChannelHandlerTimer --
+ * TransformChannelHandlerTimer --
*
- * Called by the notifier (-> timer) to flush out
- * information waiting in the input buffer.
+ * Called by the notifier (-> timer) to flush out information waiting in
+ * the input buffer.
*
- * Sideeffects:
- * As of 'Tcl_NotifyChannel'.
+ * Side effects:
+ * As of 'Tcl_NotifyChannel'.
*
- * Result:
- * None.
+ * Result:
+ * None.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
static void
-TransformChannelHandlerTimer (clientData)
- ClientData clientData; /* Transformation to query */
+TransformChannelHandlerTimer(clientData)
+ ClientData clientData; /* Transformation to query */
{
- TransformChannelData* dataPtr = (TransformChannelData*) clientData;
+ TransformChannelData *dataPtr = (TransformChannelData *) clientData;
dataPtr->timer = (Tcl_TimerToken) NULL;
if (!(dataPtr->watchMask & TCL_READABLE) ||
- (ResultLength (&dataPtr->result) == 0)) {
- /* The timer fired, but either is there no (more)
- * interest in the events it generates or nothing is available
- * for reading, so ignore it and don't recreate it.
+ (ResultLength(&dataPtr->result) == 0)) {
+ /*
+ * The timer fired, but either is there no (more) interest in the
+ * events it generates or nothing is available for reading, so ignore
+ * it and don't recreate it.
*/
return;
@@ -1265,183 +1256,183 @@ TransformChannelHandlerTimer (clientData)
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * ResultClear --
+ * ResultClear --
*
* Deallocates any memory allocated by 'ResultAdd'.
*
- * Sideeffects:
- * See above.
+ * Side effects:
+ * See above.
*
- * Result:
- * None.
+ * Result:
+ * None.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
static void
-ResultClear (r)
- ResultBuffer* r; /* Reference to the buffer to clear out */
+ResultClear(r)
+ ResultBuffer *r; /* Reference to the buffer to clear out. */
{
r->used = 0;
if (r->allocated) {
- ckfree((char*) r->buf);
- r->buf = UCHARP (NULL);
+ ckfree((char *) r->buf);
+ r->buf = UCHARP(NULL);
r->allocated = 0;
}
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * 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 (r)
- ResultBuffer* r; /* Reference to the structure to initialize */
+ResultInit(r)
+ ResultBuffer *r; /* Reference to the structure to initialize */
{
- r->used = 0;
+ r->used = 0;
r->allocated = 0;
- r->buf = UCHARP (NULL);
+ r->buf = UCHARP(NULL);
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * ResultLength --
+ * ResultLength --
*
* Returns the number of bytes stored in the buffer.
*
- * Sideeffects:
- * None.
+ * Side effects:
+ * None.
*
- * Result:
- * An integer, see above too.
+ * Result:
+ * An integer, see above too.
*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*/
static int
-ResultLength (r)
- ResultBuffer* r; /* The structure to query */
+ResultLength(r)
+ ResultBuffer *r; /* The structure to query */
{
return r->used;
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * 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 (r, buf, toRead)
- ResultBuffer* r; /* The buffer to read from */
- unsigned char* buf; /* The buffer to copy into */
- int toRead; /* Number of requested bytes */
+ResultCopy(r, buf, toRead)
+ ResultBuffer *r; /* The buffer to read from. */
+ unsigned char *buf; /* The buffer to copy into. */
+ int toRead; /* Number of requested bytes. */
{
if (r->used == 0) {
- /* Nothing to copy in the case of an empty buffer.
+ /*
+ * Nothing to copy in the case of an empty buffer.
*/
return 0;
}
if (r->used == toRead) {
- /* We have just enough. Copy everything to the caller.
+ /*
+ * We have just enough. Copy everything to the caller.
*/
- memcpy ((VOID*) buf, (VOID*) r->buf, (size_t) toRead);
+ memcpy((VOID *) buf, (VOID *) r->buf, (size_t) toRead);
r->used = 0;
return 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.
+ /*
+ * 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, (size_t) toRead);
- memmove ((VOID*) r->buf, (VOID*) (r->buf + toRead),
+ memcpy((VOID *) buf, (VOID *) r->buf, (size_t) toRead);
+ memmove((VOID *) r->buf, (VOID *) (r->buf + toRead),
(size_t) r->used - toRead);
r->used -= toRead;
return toRead;
}
- /* There is not enough in the buffer to satisfy the caller, so
- * take everything.
+ /*
+ * There is not enough in the buffer to satisfy the caller, so take
+ * everything.
*/
- memcpy((VOID*) buf, (VOID*) r->buf, (size_t) r->used);
+ memcpy((VOID *) buf, (VOID *) r->buf, (size_t) r->used);
toRead = r->used;
r->used = 0;
return toRead;
}
/*
- *------------------------------------------------------*
+ *----------------------------------------------------------------------
*
- * 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(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' */
{
if ((r->used + toWrite) > r->allocated) {
- /* Extension of the internal buffer is required.
+ /*
+ * Extension of the internal buffer is required.
*/
if (r->allocated == 0) {
r->allocated = toWrite + INCREMENT;
- r->buf = UCHARP (ckalloc((unsigned) r->allocated));
+ r->buf = UCHARP(ckalloc((unsigned) r->allocated));
} else {
r->allocated += toWrite + INCREMENT;
- r->buf = UCHARP (ckrealloc((char*) r->buf,
+ r->buf = UCHARP(ckrealloc((char *) r->buf,
(unsigned) r->allocated));
}
}
@@ -1450,3 +1441,11 @@ ResultAdd (r, buf, toWrite)
memcpy(r->buf + r->used, buf, (size_t) toWrite);
r->used += toWrite;
}
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */