General cleanup of reflected channel code

2 files changed, 1499 insertions, 1612 deletions

diff --git a/ChangeLog b/ChangeLog
index d9347d6..eae470d 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,8 +1,14 @@
+2005-10-19  Donal K. Fellows  <donal.k.fellows@manchester.ac.uk>
+
+	* generic/tclIORChan.c: General cleanup, removing checks that are
+	unnecessary due to the general contracts of other functions in the
+	core, converting to using ANSI declarations, etc. Note that nearly
+	the whole file has changed, but it is often just cosmetic.
+
 2005-10-19  Miguel Sofer <msofer@users.sf.net>
 
-	* generic/tclExecute.c (INST_DICT_APPEND, INST_DICT_LAPPEND):
-	fixed faulty peephole optimisation that can cause crashes 
-	[Bug 1331475]
+	* generic/tclExecute.c (INST_DICT_APPEND, INST_DICT_LAPPEND): fixed
+	faulty peephole optimisation that can cause crashes [Bug 1331475]
 
 2005-10-18  Don Porter  <dgp@users.sourceforge.net>
 
diff --git a/generic/tclIORChan.c b/generic/tclIORChan.c
index a3012c0..064c5cc 100644
--- a/generic/tclIORChan.c
+++ b/generic/tclIORChan.c
@@ -1,21 +1,21 @@
-/* 
+/*
  * tclIORChan.c --
  *
- *	This file contains the implementation of Tcl's generic
- *	channel reflection code, which allows the implementation
- *	of Tcl channels in Tcl code.
+ *	This file contains the implementation of Tcl's generic channel
+ *	reflection code, which allows the implementation of Tcl channels in
+ *	Tcl code.
  *
- *	Parts of this file are based on code contributed by 
- *	Jean-Claude Wippler.
+ *	Parts of this file are based on code contributed by Jean-Claude
+ *	Wippler.
  *
- *      See TIP #219 for the specification of this functionality.
+ *	See TIP #219 for the specification of this functionality.
  *
  * Copyright (c) 2004-2005 ActiveState, a divison of Sophos
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclIORChan.c,v 1.6 2005/10/05 17:44:58 andreas_kupries Exp $
+ * RCS: @(#) $Id: tclIORChan.c,v 1.7 2005/10/19 13:59:01 dkf Exp $
  */
 
 #include <tclInt.h>
@@ -23,77 +23,56 @@
 #include <assert.h>
 
 #ifndef EINVAL
-#define EINVAL 9
+#define EINVAL	9
 #endif
 #ifndef EOK
-#define EOK    0
+#define EOK	0
 #endif
 
 /*
  * Signatures of all functions used in the C layer of the reflection.
  */
 
-/* Required */
-static int	RcClose _ANSI_ARGS_((ClientData clientData,
-		   Tcl_Interp *interp));
-
-/* Required, "read" is optional despite this. */
-static int	RcInput _ANSI_ARGS_((ClientData clientData,
-		    char *buf, int toRead, int *errorCodePtr));
-
-/* Required, "write" is optional despite this. */
-static int	RcOutput _ANSI_ARGS_((ClientData clientData,
-	            CONST char *buf, int toWrite, int *errorCodePtr));
-
-/* Required */
-static void	RcWatch _ANSI_ARGS_((ClientData clientData, int mask));
-
-/* NULL'able - "blocking", is optional */
-static int	RcBlock _ANSI_ARGS_((ClientData clientData,
-				       int mode));
-
-/* NULL'able - "seek", is optional */
-static Tcl_WideInt RcSeekWide _ANSI_ARGS_((ClientData clientData,
-		    Tcl_WideInt offset,
-		    int mode, int *errorCodePtr));
-
-static int RcSeek _ANSI_ARGS_((ClientData clientData,
-		    long offset, int mode, int *errorCodePtr));
-
-/* NULL'able - "cget" / "cgetall", are optional */
-static int	RcGetOption _ANSI_ARGS_((ClientData clientData,
-				       Tcl_Interp* interp,
-				       CONST char *optionName,
-				       Tcl_DString *dsPtr));
-
-/* NULL'able - "configure", is optional */
-static int	RcSetOption _ANSI_ARGS_((ClientData clientData,
-				       Tcl_Interp* interp,
-				       CONST char *optionName,
-				       CONST char *newValue));
-
+static int		ReflectClose(ClientData clientData,
+			    Tcl_Interp *interp);
+static int		ReflectInput(ClientData clientData, char *buf,
+			    int toRead, int *errorCodePtr);
+static int		ReflectOutput(ClientData clientData, CONST char *buf,
+			    int toWrite, int *errorCodePtr);
+static void		ReflectWatch(ClientData clientData, int mask);
+static int		ReflectBlock(ClientData clientData, int mode);
+static Tcl_WideInt	ReflectSeekWide(ClientData clientData,
+			    Tcl_WideInt offset, int mode, int *errorCodePtr);
+static int		ReflectSeek(ClientData clientData, long offset,
+			    int mode, int *errorCodePtr);
+static int		ReflectGetOption(ClientData clientData,
+			    Tcl_Interp *interp, CONST char *optionName,
+			    Tcl_DString *dsPtr);
+static int		ReflectSetOption(ClientData clientData,
+			    Tcl_Interp *interp, CONST char *optionName,
+			    CONST char *newValue);
 
 /*
- * 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. This is
+ * a version 3 structure.
  */
 
 static Tcl_ChannelType tclRChannelType = {
-  "tclrchannel",  /* Type name.                                    */
-  TCL_CHANNEL_VERSION_3,
-  RcClose,        /* Close channel, clean instance data            */
-  RcInput,        /* Handle read request                           */
-  RcOutput,       /* Handle write request                          */
-  RcSeek,         /* Move location of access point.    NULL'able   */
-  RcSetOption,    /* Set options.                      NULL'able   */
-  RcGetOption,    /* Get options.                      NULL'able   */
-  RcWatch,        /* Initialize notifier                           */
-  NULL,           /* Get OS handle from the channel.   NULL'able   */
-  NULL,           /* No close2 support.                NULL'able   */
-  RcBlock,        /* Set blocking/nonblocking.         NULL'able   */
-  NULL,           /* Flush channel. Not used by core.  NULL'able   */
-  NULL,           /* Handle events.                    NULL'able   */
-  RcSeekWide      /* Move access point (64 bit).       NULL'able   */
+    "tclrchannel",	/* Type name.					*/
+    TCL_CHANNEL_VERSION_3,
+    ReflectClose,	/* Close channel, clean instance data		*/
+    ReflectInput,	/* Handle read request				*/
+    ReflectOutput,	/* Handle write request				*/
+    ReflectSeek,	/* Move location of access point.    NULL'able	*/
+    ReflectSetOption,	/* Set options.			     NULL'able	*/
+    ReflectGetOption,	/* Get options.			     NULL'able	*/
+    ReflectWatch,	/* Initialize notifier				*/
+    NULL,		/* Get OS handle from the channel.   NULL'able	*/
+    NULL,		/* No close2 support.		     NULL'able	*/
+    ReflectBlock,	/* Set blocking/nonblocking.	     NULL'able	*/
+    NULL,		/* Flush channel. Not used by core.  NULL'able	*/
+    NULL,		/* Handle events.		     NULL'able	*/
+    ReflectSeekWide	/* Move access point (64 bit).	     NULL'able	*/
 };
 
 /*
@@ -101,75 +80,69 @@ static Tcl_ChannelType tclRChannelType = {
  */
 
 typedef struct {
-  Tcl_Channel chan;    /* Back reference to generic channel structure.
-		        */
-  Tcl_Interp* interp;  /* Reference to the interpreter containing the
-		        * Tcl level part of the channel. */
+    Tcl_Channel chan;		/* Back reference to generic channel
+				 * structure. */
+    Tcl_Interp *interp;		/* Reference to the interpreter containing the
+				 * Tcl level part of the channel. */
 #ifdef TCL_THREADS
-  Tcl_ThreadId thread; /* Thread the 'interp' belongs to. */
+    Tcl_ThreadId thread;	/* Thread the 'interp' belongs to. */
 #endif
 
-  /* See [==] as well.
-   * Storage for the command prefix and the additional words required
-   * for the invocation of methods in the command handler.
-   *
-   * argv [0] ... [.] | [argc-2] [argc-1] | [argc]  [argc+2]
-   *      cmd ... pfx | method   chan     | detail1 detail2
-   *      ~~~~ CT ~~~            ~~ CT ~~
-   *
-   * CT = Belongs to the 'Command handler Thread'.
-   */
-
-  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 */
-
-  /* ---------------------------------------- */
-
-  /* NOTE (9): Should we have predefined shared literals
-   * NOTE (9): for the method names ?
-   */
-
-  /* ---------------------------------------- */
-
-  int mode;             /* Mask of R/W mode */
-  int interest;         /* Mask of events the channel is interested in. */
-
-  /* Note regarding the usage of timers.
-   *
-   * Most channel implementations need a timer in the
-   * C level to ensure that data in buffers is flushed
-   * out through the generation of fake file events.
-   *
-   * See 'rechan', 'memchan', etc.
-   *
-   * Here this is _not_ required. Interest in events is
-   * posted to the Tcl level via 'watch'. And posting of
-   * events is possible from the Tcl level as well, via
-   * 'chan postevent'. This means that the generation of
-   * all events, fake or not, timer based or not, is
-   * completely in the hands of the Tcl level. Therefore
-   * no timer here.
-   */
-
-} ReflectingChannel;
+    /* See [==] as well.
+     * Storage for the command prefix and the additional words required for
+     * the invocation of methods in the command handler.
+     *
+     * argv [0] ... [.] | [argc-2] [argc-1] | [argc]  [argc+2]
+     *      cmd ... pfx | method   chan     | detail1 detail2
+     *      ~~~~ CT ~~~            ~~ CT ~~
+     *
+     * CT = Belongs to the 'Command handler Thread'.
+     */
+
+    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 */
+
+    /*
+     * NOTE (9): Should we have predefined shared literals for the method
+     * names?
+     */
+
+    int mode;			/* Mask of R/W mode */
+    int interest;		/* Mask of events the channel is interested
+				 * in. */
+
+    /*
+     * Note regarding the usage of timers.
+     *
+     * Most channel implementations need a timer in the C level to ensure that
+     * data in buffers is flushed out through the generation of fake file
+     * events.
+     *
+     * See 'rechan', 'memchan', etc.
+     *
+     * Here this is _not_ required. Interest in events is posted to the Tcl
+     * level via 'watch'. And posting of events is possible from the Tcl level
+     * as well, via 'chan postevent'. This means that the generation of all
+     * events, fake or not, timer based or not, is completely in the hands of
+     * the Tcl level. Therefore no timer here.
+     */
+} ReflectedChannel;
 
 /*
  * Event literals. ==================================================
  */
 
 static CONST char *eventOptions[] = {
-  "read", "write", (char *) NULL
+    "read", "write", NULL
 };
 typedef enum {
-  EVENT_READ, EVENT_WRITE
+    EVENT_READ, EVENT_WRITE
 } EventOption;
 
 /*
@@ -177,49 +150,51 @@ typedef enum {
  */
 
 static CONST char *methodNames[] = {
-  "blocking",	/* OPT */
-  "cget",	/* OPT \/ Together or none */
-  "cgetall",	/* OPT /\ of these two     */
-  "configure",	/* OPT */
-  "finalize",	/*     */
-  "initialize",	/*     */
-  "read",	/* OPT */
-  "seek",	/* OPT */
-  "watch",	/*     */
-  "write",	/* OPT */
-  (char *) NULL
+    "blocking",		/* OPT */
+    "cget",		/* OPT \/ Together or none */
+    "cgetall",		/* OPT /\ of these two     */
+    "configure",	/* OPT */
+    "finalize",		/*     */
+    "initialize",	/*     */
+    "read",		/* OPT */
+    "seek",		/* OPT */
+    "watch",		/*     */
+    "write",		/* OPT */
+    NULL
 };
 typedef enum {
-  METH_BLOCKING,
-  METH_CGET,
-  METH_CGETALL,
-  METH_CONFIGURE,
-  METH_FINAL,
-  METH_INIT,
-  METH_READ,
-  METH_SEEK,
-  METH_WATCH,
-  METH_WRITE,
+    METH_BLOCKING,
+    METH_CGET,
+    METH_CGETALL,
+    METH_CONFIGURE,
+    METH_FINAL,
+    METH_INIT,
+    METH_READ,
+    METH_SEEK,
+    METH_WATCH,
+    METH_WRITE,
 } MethodName;
 
 #define FLAG(m) (1 << (m))
-#define REQUIRED_METHODS (FLAG (METH_INIT) | FLAG (METH_FINAL) | FLAG (METH_WATCH))
-#define NULLABLE_METHODS (FLAG (METH_BLOCKING) | FLAG (METH_SEEK) | \
-	FLAG (METH_CONFIGURE) | FLAG (METH_CGET) | FLAG (METH_CGETALL))
+#define REQUIRED_METHODS \
+	(FLAG(METH_INIT) | FLAG(METH_FINAL) | FLAG(METH_WATCH))
+#define NULLABLE_METHODS \
+	(FLAG(METH_BLOCKING) | FLAG(METH_SEEK) | \
+	FLAG(METH_CONFIGURE) | FLAG(METH_CGET) | FLAG(METH_CGETALL))
 
-#define RANDW (TCL_READABLE|TCL_WRITABLE)
+#define RANDW \
+	(TCL_READABLE | TCL_WRITABLE)
 
-#define IMPLIES(a,b) ((!(a)) || (b))
+#define IMPLIES(a,b)	((!(a)) || (b))
 #define NEGIMPL(a,b)
-#define HAS(x,f) (x & FLAG(f))
-
+#define HAS(x,f)	(x & FLAG(f))
 
 #ifdef TCL_THREADS
 /*
  * Thread specific types and structures.
  *
- * We are here essentially creating a very specific implementation of
- * 'thread send'.
+ * We are here essentially creating a very specific implementation of 'thread
+ * send'.
  */
 
 /*
@@ -227,216 +202,211 @@ typedef enum {
  */
 
 typedef enum {
-  RcOpClose,
-  RcOpInput,
-  RcOpOutput,
-  RcOpSeek,
-  RcOpWatch,
-  RcOpBlock,
-  RcOpSetOpt,
-  RcOpGetOpt,
-  RcOpGetOptAll
-} RcOperation;
+    ForwardedClose,
+    ForwardedInput,
+    ForwardedOutput,
+    ForwardedSeek,
+    ForwardedWatch,
+    ForwardedBlock,
+    ForwardedSetOpt,
+    ForwardedGetOpt,
+    ForwardedGetOptAll
+} ForwardedOperation;
 
 /*
- * 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), 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 sharing
- * problems.
+ * 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),
+ * 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
+ * sharing problems.
  */
 
-typedef struct RcForwardParamBase {
-  int   code; /* O: Ok/Fail of the cmd handler */
-  char* msg;  /* O: Error message for handler failure */
-  int   vol;  /* O: True - msg is allocated, False - msg is static */
-} RcForwardParamBase;
+typedef struct ForwardParamBase {
+    int code;			/* O: Ok/Fail of the cmd handler */
+    char *msgStr;		/* O: Error message for handler failure */
+    int mustFree;		/* O: True if msgStr is allocated, false if
+				 * otherwise (static). */
+} ForwardParamBase;
 
 /*
- * Operation specific parameter/result structures.
+ * Operation specific parameter/result structures. (These are "subtypes" of
+ * ForwardParamBase. Where an operation does not need any special types, it
+ * has no "subtype" and just uses ForwardParamBase, as listed above.)
  */
 
-typedef struct RcForwardParamClose {
-  RcForwardParamBase b;
-} RcForwardParamClose;
-
-typedef struct RcForwardParamInput {
-  RcForwardParamBase b;
-  char* buf;    /* O: Where to store the read bytes */
-  int   toRead; /* I: #bytes to read,
-		 * O: #bytes actually read */
-} RcForwardParamInput;
-
-typedef struct RcForwardParamOutput {
-  RcForwardParamBase b;
-  CONST char* buf;     /* I: Where the bytes to write come from */
-  int         toWrite; /* I: #bytes to write,
-			* O: #bytes actually written */
-} RcForwardParamOutput;
-
-typedef struct RcForwardParamSeek {
-  RcForwardParamBase b;
-  int         seekMode; /* I: How to seek */
-  Tcl_WideInt offset;   /* I: Where to seek,
-			 * O: New location */
-} RcForwardParamSeek;
-
-typedef struct RcForwardParamWatch {
-  RcForwardParamBase b;
-  int mask; /* I: What events to watch for */
-} RcForwardParamWatch;
-
-typedef struct RcForwardParamBlock {
-  RcForwardParamBase b;
-  int nonblocking; /* I: What mode to activate */
-} RcForwardParamBlock;
-
-typedef struct RcForwardParamSetOpt {
-  RcForwardParamBase b;
-  CONST char* name;  /* Name of option to set */
-  CONST char* value; /* Value to set */
-} RcForwardParamSetOpt;
-
-typedef struct RcForwardParamGetOpt {
-  RcForwardParamBase b;
-  CONST char*  name;  /* Name of option to get, maybe NULL */
-  Tcl_DString* value; /* Result */
-} RcForwardParamGetOpt;
+struct ForwardParamInput {
+    ForwardParamBase base;	/* "Supertype". MUST COME FIRST. */
+    char *buf;			/* O: Where to store the read bytes */
+    int toRead;			/* I: #bytes to read,
+				 * O: #bytes actually read */
+};
+struct ForwardParamOutput {
+    ForwardParamBase base;	/* "Supertype". MUST COME FIRST. */
+    CONST char *buf;		/* I: Where the bytes to write come from */
+    int toWrite;		/* I: #bytes to write,
+				 * O: #bytes actually written */
+};
+struct ForwardParamSeek {
+    ForwardParamBase base;	/* "Supertype". MUST COME FIRST. */
+    int seekMode;		/* I: How to seek */
+    Tcl_WideInt offset;		/* I: Where to seek,
+				 * O: New location */
+};
+struct ForwardParamWatch {
+    ForwardParamBase base;	/* "Supertype". MUST COME FIRST. */
+    int mask;			/* I: What events to watch for */
+};
+struct ForwardParamBlock {
+    ForwardParamBase base;	/* "Supertype". MUST COME FIRST. */
+    int nonblocking;		/* I: What mode to activate */
+};
+struct ForwardParamSetOpt {
+    ForwardParamBase base;	/* "Supertype". MUST COME FIRST. */
+    CONST char *name;		/* Name of option to set */
+    CONST char *value;		/* Value to set */
+};
+struct ForwardParamGetOpt {
+    ForwardParamBase base;	/* "Supertype". MUST COME FIRST. */
+    CONST char *name;		/* Name of option to get, maybe NULL */
+    Tcl_DString *value;		/* Result */
+};
 
 /*
- * General event structure, with reference to
- * operation specific data.
+ * Now join all these together in a single union for convenience.
  */
 
-typedef struct RcForwardingEvent {
-  Tcl_Event                  event; /* Basic event data, has to be first item */
-  struct RcForwardingResult* resultPtr;
-
-  RcOperation               op;    /* Forwarded driver operation */
-  ReflectingChannel*        rcPtr; /* Channel instance */
-  CONST RcForwardParamBase* param; /* Arguments, a RcForwardParamXXX pointer */
-} RcForwardingEvent;
+typedef union ForwardParam {
+    ForwardParamBase base;
+    struct ForwardParamInput input;
+    struct ForwardParamOutput output;
+    struct ForwardParamSeek seek;
+    struct ForwardParamWatch watch;
+    struct ForwardParamBlock block;
+    struct ForwardParamSetOpt setOpt;
+    struct ForwardParamGetOpt getOpt;
+} ForwardParam;
 
 /*
- * Structure to manage the result of the forwarding.  This is not the
- * result of the operation itself, but about the success of the
- * forward event itself. The event can be successful, even if the
- * operation which was forwarded failed. It is also there to manage
- * the synchronization between the involved threads.
+ * Forward declaration.
  */
 
-typedef struct RcForwardingResult {
-
-  Tcl_ThreadId  src;    /* Originating thread. */
-  Tcl_ThreadId  dst;    /* Thread the op was forwarded to. */
-  Tcl_Condition done;   /* Condition variable the forwarder blocks on. */
-  int           result; /* TCL_OK or TCL_ERROR */
-
-  struct RcForwardingEvent*  evPtr; /* Event the result belongs to. */
-
-  struct RcForwardingResult* prevPtr; /* Links into the list of pending */
-  struct RcForwardingResult* nextPtr; /* forwarded results. */
-
-} RcForwardingResult;
+typedef struct ForwardingResult ForwardingResult;
 
 /*
- * List of forwarded operations which have not completed yet, plus the
- * mutex to protect the access to this process global list.
+ * General event structure, with reference to operation specific data.
  */
 
-static RcForwardingResult* forwardList = (RcForwardingResult*) NULL;
-TCL_DECLARE_MUTEX (rcForwardMutex)
+typedef struct ForwardingEvent {
+    Tcl_Event event;		/* Basic event data, has to be first item */
+    ForwardingResult *resultPtr;
+    ForwardedOperation op;	/* Forwarded driver operation */
+    ReflectedChannel *rcPtr;	/* Channel instance */
+    CONST ForwardParam *param;	/* Arguments, a ForwardParamXXX pointer */
+} ForwardingEvent;
 
 /*
- * Function containing the generic code executing a forward, and
- * wrapper macros for the actual operations we wish to forward.
+ * Structure to manage the result of the forwarding. This is not the result of
+ * the operation itself, but about the success of the forward event itself.
+ * The event can be successful, even if the operation which was forwarded
+ * failed. It is also there to manage the synchronization between the involved
+ * threads.
  */
 
-static void
-RcForwardOp _ANSI_ARGS_ ((ReflectingChannel* rcPtr, RcOperation op,
-			  Tcl_ThreadId dst, CONST VOID* param));
+struct ForwardingResult {
+    Tcl_ThreadId src;		/* Originating thread. */
+    Tcl_ThreadId dst;		/* Thread the op was forwarded to. */
+    Tcl_Condition done;		/* Condition variable the forwarder blocks
+				 * on. */
+    int result;			/* TCL_OK or TCL_ERROR */
+    ForwardingEvent *evPtr;	/* Event the result belongs to. */
+    ForwardingResult *prevPtr, *nextPtr;
+				/* Links into the list of pending forwarded
+				 * results. */
+};
 
 /*
- * The event function executed by the thread receiving a forwarding
- * event. Executes the appropriate function and collects the result,
- * if any.
+ * List of forwarded operations which have not completed yet, plus the mutex
+ * to protect the access to this process global list.
  */
 
-static int
-RcForwardProc _ANSI_ARGS_ ((Tcl_Event *evPtr, int mask));
+static ForwardingResult *forwardList = NULL;
+TCL_DECLARE_MUTEX(rcForwardMutex)
 
 /*
- * Helpers which intercept when threads are going away, and clean up
- * after pending forwarding events. Different actions depending on
- * which thread went away, originator (src), or receiver (dst).
+ * Function containing the generic code executing a forward, and wrapper
+ * macros for the actual operations we wish to forward. Uses ForwardProc as
+ * the event function executed by the thread receiving a forwarding event
+ * (which executes the appropriate function and collects the result, if any).
+ *
+ * The two ExitProcs are handlers so that things do not deadlock when either
+ * thread involved in the forwarding exits. They also clean things up so that
+ * we don't leak resources when threads go away.
  */
 
-static void
-RcSrcExitProc _ANSI_ARGS_ ((ClientData clientData));
-
-static void
-RcDstExitProc _ANSI_ARGS_ ((ClientData clientData));
-
-#define RcFreeReceivedError(pb) \
-	if ((pb).vol) {ckfree ((pb).msg);}
-
-#define RcPassReceivedErrorInterp(i,pb) \
-	if ((i)) {Tcl_SetChannelErrorInterp ((i), Tcl_NewStringObj ((pb).msg,-1));} \
-	RcFreeReceivedError (pb)
-
-#define RcPassReceivedError(c,pb) \
-	Tcl_SetChannelError ((c), Tcl_NewStringObj ((pb).msg,-1)); \
-	RcFreeReceivedError (pb)
-
-#define RcForwardSetStaticError(p,emsg) \
-       (p)->code = TCL_ERROR; (p)->vol  = 0; (p)->msg  = (char*) (emsg);
-
-#define RcForwardSetDynError(p,emsg) \
-       (p)->code = TCL_ERROR; (p)->vol  = 1; (p)->msg  = (char*) (emsg);
-
-static void
-RcForwardSetObjError _ANSI_ARGS_ ((RcForwardParamBase* p,
-				   Tcl_Obj*            obj));
+static void		ForwardOpToOwnerThread(ReflectedChannel *rcPtr,
+			    ForwardedOperation op, CONST VOID *param);
+static int		ForwardProc(Tcl_Event *evPtr, int mask);
+static void		SrcExitProc(ClientData clientData);
+static void		DstExitProc(ClientData clientData);
 
+#define FreeReceivedError(p) \
+	if ((p)->base.mustFree) { \
+	    ckfree((p)->base.msgStr); \
+	}
+#define PassReceivedErrorInterp(i,pb) \
+	if ((i) != NULL) { \
+            Tcl_Obj *preiTmpObj; \
+	    TclNewStringObj(preiTmpObj, (p)->base.msgStr, -1); \
+	    Tcl_SetChannelErrorInterp((i), preiTmpObj); \
+	} \
+	FreeReceivedError(p)
+#define PassReceivedError(c,p) \
+	{ \
+	    Tcl_Obj *preTmpObj; \
+	    TclNewStringObj(preTmpObj, (p)->base.msgStr, -1); \
+	    Tcl_SetChannelError((c), preTmpObj); \
+	    FreeReceivedError(p); \
+	}
+#define ForwardSetStaticError(p,emsg) \
+	(p)->base.code = TCL_ERROR; \
+	(p)->base.mustFree = 0; \
+	(p)->base.msgStr = (char *) (emsg);
+#define ForwardSetDynamicError(p,emsg) \
+	(p)->base.code = TCL_ERROR; \
+	(p)->base.mustFree = 1; \
+	(p)->base.msgStr = (char *) (emsg);
+
+static void		ForwardSetObjError(ForwardParam *p,
+			    Tcl_Obj *objPtr);
 #endif /* TCL_THREADS */
 
-#define RcSetChannelErrorStr(c,msg) \
-	Tcl_SetChannelError ((c), Tcl_NewStringObj ((msg),-1))
-
-static Tcl_Obj* RcErrorMarshall _ANSI_ARGS_ ((Tcl_Interp *interp));
-static void     RcErrorReturn   _ANSI_ARGS_ ((Tcl_Interp* interp, Tcl_Obj* msg));
+#define SetChannelErrorStr(c,msgStr) \
+	Tcl_SetChannelError((c), Tcl_NewStringObj((msgStr), -1))
 
+static Tcl_Obj *	MarshallError(Tcl_Interp *interp);
+static void		UnmarshallErrorResult(Tcl_Interp *interp,
+			    Tcl_Obj *msgObj);
 
-
 /*
  * Static functions for this file:
  */
 
-static int RcEncodeEventMask _ANSI_ARGS_((Tcl_Interp* interp,
-		 CONST char* objName, Tcl_Obj* obj,
-		 int* mask));
-
-static Tcl_Obj* RcDecodeEventMask _ANSI_ARGS_ ((int mask));
-
-static ReflectingChannel* RcNew _ANSI_ARGS_ ((Tcl_Interp* interp,
-	     Tcl_Obj* cmdpfxObj, int mode,
-	     Tcl_Obj* id));
-
-static Tcl_Obj* RcNewHandle _ANSI_ARGS_ ((void));
+static int		EncodeEventMask(Tcl_Interp *interp,
+			    CONST char *objName, Tcl_Obj *obj, int *mask);
+static Tcl_Obj *	DecodeEventMask(int mask);
+static ReflectedChannel * NewReflectedChannel(Tcl_Interp *interp,
+			    Tcl_Obj *cmdpfxObj, int mode, Tcl_Obj *handleObj);
+static Tcl_Obj *	NextHandle(void);
+static void		FreeReflectedChannel(ReflectedChannel *rcPtr);
+static int		InvokeTclMethod(ReflectedChannel *rcPtr,
+			    CONST char *method, Tcl_Obj *argOneObj,
+			    Tcl_Obj *argTwoObj, Tcl_Obj **resultObjPtr,
+			    int flags);
 
-static void RcFree _ANSI_ARGS_ ((ReflectingChannel* rcPtr));
-
-static void
-RcInvokeTclMethod _ANSI_ARGS_((ReflectingChannel* rcPtr,
-       CONST char* method, Tcl_Obj* argone, Tcl_Obj* argtwo,
-       int* result, Tcl_Obj** resultObj, int capture));
-
-#define NO_CAPTURE (0)
-#define DO_CAPTURE (1)
+#define INVOKE_NO_CAPTURE	0x01
 
 /*
  * Global constant strings (messages). ==================
@@ -445,15 +415,14 @@ RcInvokeTclMethod _ANSI_ARGS_((ReflectingChannel* rcPtr,
  * list-quoting to keep the words of the message together. See also [x].
  */
 
-static CONST char* msg_read_unsup       = "{read not supported by Tcl driver}";
-static CONST char* msg_read_toomuch     = "{read delivered more than requested}";
-static CONST char* msg_write_unsup      = "{write not supported by Tcl driver}";
-static CONST char* msg_write_toomuch    = "{write wrote more than requested}";
-static CONST char* msg_seek_beforestart = "{Tried to seek before origin}";
-
+static CONST char *msg_read_unsup = "{read not supported by Tcl driver}";
+static CONST char *msg_read_toomuch = "{read delivered more than requested}";
+static CONST char *msg_write_unsup = "{write not supported by Tcl driver}";
+static CONST char *msg_write_toomuch = "{write wrote more than requested}";
+static CONST char *msg_seek_beforestart = "{Tried to seek before origin}";
 #ifdef TCL_THREADS
-static CONST char* msg_send_originlost  = "{Origin thread lost}";
-static CONST char* msg_send_dstlost     = "{Destination thread lost}";
+static CONST char *msg_send_originlost = "{Origin thread lost}";
+static CONST char *msg_send_dstlost = "{Destination thread lost}";
 #endif /* TCL_THREADS */
 
 /*
@@ -465,12 +434,12 @@ static CONST char* msg_send_dstlost     = "{Destination thread lost}";
  *
  * TclChanCreateObjCmd --
  *
- *	This procedure is invoked to process the "chan create" Tcl
- *	command. See the user documentation for details on what it does.
+ *	This function is invoked to process the "chan create" 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 interp result.
+ *	A standard Tcl result. The handle of the new channel is placed in the
+ *	interp result.
  *
  * Side effects:
  *	Creates a new channel.
@@ -479,223 +448,226 @@ static CONST char* msg_send_dstlost     = "{Destination thread lost}";
  */
 
 int
-TclChanCreateObjCmd (/*ignored*/ clientData, interp, objc, objv)
-     ClientData      clientData;
-     Tcl_Interp*     interp;
-     int             objc;
-     Tcl_Obj* CONST* objv;
+TclChanCreateObjCmd(
+    ClientData clientData,
+    Tcl_Interp *interp,
+    int objc,
+    Tcl_Obj *CONST *objv)
 {
-    ReflectingChannel* rcPtr;       /* Instance data of the new channel */
-    Tcl_Obj*           rcId;        /* Handle of the new channel */
-    int                mode;        /* R/W mode of new channel. Has to
-				     * match abilities of handler commands */
-    Tcl_Obj*           cmdObj;      /* Command prefix, list of words */
-    Tcl_Obj*           cmdNameObj;  /* Command name */
-    Tcl_Channel        chan;        /* Token for the new 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 */
-    int                res;         /* Result code for 'initialize' */
-    Tcl_Obj*           resObj;      /* Result data for 'initialize' */
-    int                methods;     /* Bitmask for supported methods. */
-    Channel*           chanPtr;     /* 'chan' resolved to internal struct. */
-
-    /* Syntax:   chan create MODE CMDPREFIX
+    ReflectedChannel *rcPtr;	/* Instance data of the new channel */
+    Tcl_Obj *rcId;		/* Handle of the new channel */
+    int mode;			/* R/W mode of new channel. Has to match
+				 * abilities of handler commands */
+    Tcl_Obj *cmdObj;		/* Command prefix, list of words */
+    Tcl_Obj *cmdNameObj;	/* Command name */
+    Tcl_Channel chan;		/* Token for the new 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 */
+    int result;			/* Result code for 'initialize' */
+    Tcl_Obj *resObj;		/* Result data for 'initialize' */
+    int methods;		/* Bitmask for supported methods. */
+    Channel *chanPtr;		/* 'chan' resolved to internal struct. */
+
+    /*
+     * Syntax:   chan create MODE CMDPREFIX
      *           [0]  [1]    [2]  [3]
      *
      * Actually: rCreate MODE CMDPREFIX
      *           [0]     [1]  [2]
      */
 
-#define MODE (1)
-#define CMD  (2)
+#define MODE	(1)
+#define CMD	(2)
 
-    /* Number of arguments ... */
+    /*
+     * Number of arguments...
+     */
 
     if (objc != 3) {
-        Tcl_WrongNumArgs(interp, 1, objv, "mode cmdprefix");
+	Tcl_WrongNumArgs(interp, 1, objv, "mode cmdprefix");
 	return TCL_ERROR;
     }
 
-    /* First argument is a list of modes. Allowed entries are "read",
-     * "write". Expect at least one list element.  Abbreviations are
-     * ok.
+    /*
+     * First argument is a list of modes. Allowed entries are "read", "write".
+     * Expect at least one list element. Abbreviations are ok.
      */
 
-    modeObj = objv [MODE];
-    if (RcEncodeEventMask (interp, "mode", objv [MODE], &mode) != TCL_OK) {
-        return TCL_ERROR;
+    modeObj = objv[MODE];
+    if (EncodeEventMask(interp, "mode", objv[MODE], &mode) != TCL_OK) {
+	return TCL_ERROR;
     }
 
-    /* Second argument is command prefix, i.e. list of words, first
-     * word is name of handler command, other words are fixed
-     * arguments. Run 'initialize' method to get the list of supported
-     * methods. Validate this.
+    /*
+     * Second argument is command prefix, i.e. list of words, first word is
+     * name of handler command, other words are fixed arguments. Run
+     * 'initialize' method to get the list of supported methods. Validate
+     * this.
      */
 
-    cmdObj = objv [CMD];
+    cmdObj = objv[CMD];
 
-    /* Basic check that the command prefix truly is a list. */
+    /*
+     * Basic check that the command prefix truly is a list.
+     */
 
     if (Tcl_ListObjIndex(interp, cmdObj, 0, &cmdNameObj) != TCL_OK) {
-        return TCL_ERROR;
+	return TCL_ERROR;
     }
 
-    /* Now create the channel.
+    /*
+     * Now create the channel.
      */
 
-    rcId  = RcNewHandle ();
-    rcPtr = RcNew (interp, cmdObj, mode, rcId);
-    chan  = Tcl_CreateChannel (&tclRChannelType,
-			       Tcl_GetString (rcId),
-			       rcPtr, mode);
+    rcId = NextHandle();
+    rcPtr = NewReflectedChannel(interp, cmdObj, mode, rcId);
+    chan = Tcl_CreateChannel(&tclRChannelType, TclGetString(rcId), rcPtr,
+	    mode);
     rcPtr->chan = chan;
-    chanPtr = (Channel*) chan;
-
-    /* Invoke 'initialize' and validate that the handler
-     * is present and ok. Squash the channel if not.
-     */
+    chanPtr = (Channel *) chan;
 
-    /* Note: The conversion of 'mode' back into a Tcl_Obj ensures that
+    /*
+     * Invoke 'initialize' and validate that the handler is present and ok.
+     * Squash the channel if not.
+     *
+     * Note: The conversion of 'mode' back into a Tcl_Obj ensures that
      * 'initialize' is invoked with canonical mode names, and no
-     * abbreviations. Using modeObj directly could feed abbreviations
-     * into the handler, and the handler is not specified to handle
-     * such.
+     * abbreviations. Using modeObj directly could feed abbreviations into the
+     * handler, and the handler is not specified to handle such.
      */
 
-    modeObj = RcDecodeEventMask (mode);
-    RcInvokeTclMethod (rcPtr, "initialize", modeObj, NULL,
-		       &res, &resObj, NO_CAPTURE);
-    Tcl_DecrRefCount (modeObj);
+    modeObj = DecodeEventMask(mode);
+    result = InvokeTclMethod(rcPtr, "initialize", modeObj, NULL, &resObj,
+	    INVOKE_NO_CAPTURE);
+    Tcl_DecrRefCount(modeObj);
+    if (result != TCL_OK) {
+	Tcl_Obj *err = Tcl_NewStringObj("Initialize failure: ", -1);
 
-    if (res != TCL_OK) {
-        Tcl_Obj* err = Tcl_NewStringObj ("Initialize failure: ",-1);
-
-	Tcl_AppendObjToObj(err,resObj);
-	Tcl_SetObjResult (interp,err);
-	Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
+	Tcl_AppendObjToObj(err, resObj);
+	Tcl_SetObjResult(interp, err);
+	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
 	goto error;
     }
 
-    /* Verify the result.
+    /*
+     * Verify the result.
      * - List, of method names. Convert to mask.
      *   Check for non-optionals through the mask.
      *   Compare open mode against optional r/w.
      */
 
-    Tcl_AppendResult (interp, "Initialize failure: ", (char*) NULL);
+    Tcl_AppendResult(interp, "Initialize failure: ", NULL);
 
-    if (Tcl_ListObjGetElements (interp, resObj,
-			&listc, &listv) != TCL_OK) {
-        /* The function above replaces my prefix in case of an error,
-	 * so more work for us to get the prefix back into the error
-	 * message
+    if (Tcl_ListObjGetElements(interp, resObj, &listc, &listv) != TCL_OK) {
+	/*
+	 * The function above replaces my prefix in case of an error, so more
+	 * work for us to get the prefix back into the error message
 	 */
 
-        Tcl_Obj* err = Tcl_NewStringObj ("Initialize failure: ",-1);
+	Tcl_Obj *err = Tcl_NewStringObj("Initialize failure: ", -1);
 
-	Tcl_AppendObjToObj(err,Tcl_GetObjResult (interp));
-	Tcl_SetObjResult (interp,err);
+	Tcl_AppendObjToObj(err, Tcl_GetObjResult(interp));
+	Tcl_SetObjResult(interp, err);
 	goto error;
     }
 
     methods = 0;
     while (listc > 0) {
-        if (Tcl_GetIndexFromObj (interp, listv [listc-1],
-				 methodNames, "method", TCL_EXACT, &methIndex) != TCL_OK) {
-	    Tcl_Obj* err = Tcl_NewStringObj ("Initialize failure: ",-1);
+	if (Tcl_GetIndexFromObj(interp, listv[listc-1], methodNames,
+		"method", TCL_EXACT, &methIndex) != TCL_OK) {
+	    Tcl_Obj *err = Tcl_NewStringObj("Initialize failure: ", -1);
 
-	    Tcl_AppendObjToObj(err,Tcl_GetObjResult (interp));
-	    Tcl_SetObjResult (interp,err);
+	    Tcl_AppendObjToObj(err, Tcl_GetObjResult(interp));
+	    Tcl_SetObjResult(interp, err);
 	    goto error;
 	}
 
-	methods |= FLAG (methIndex);
-	listc --;
+	methods |= FLAG(methIndex);
+	listc--;
     }
 
     if ((REQUIRED_METHODS & methods) != REQUIRED_METHODS) {
-        Tcl_AppendResult (interp, "Not all required methods supported",
-			  (char*) NULL);
+	Tcl_AppendResult(interp, "Not all required methods supported", NULL);
 	goto error;
     }
 
-    if ((mode & TCL_READABLE) && !HAS(methods,METH_READ)) {
-        Tcl_AppendResult (interp, "Reading not supported, but requested",
-			  (char*) NULL);
+    if ((mode & TCL_READABLE) && !HAS(methods, METH_READ)) {
+	Tcl_AppendResult(interp, "Reading not supported, but requested", NULL);
 	goto error;
     }
 
-    if ((mode & TCL_WRITABLE) && !HAS(methods,METH_WRITE)) {
-        Tcl_AppendResult (interp, "Writing not supported, but requested",
-			  (char*) NULL);
+    if ((mode & TCL_WRITABLE) && !HAS(methods, METH_WRITE)) {
+	Tcl_AppendResult(interp, "Writing not supported, but requested", NULL);
 	goto error;
     }
 
-    if (!IMPLIES (HAS(methods,METH_CGET), HAS(methods,METH_CGETALL))) {
-        Tcl_AppendResult (interp, "'cgetall' not supported, but should be, as 'cget' is",
-			  (char*) NULL);
+    if (!IMPLIES(HAS(methods, METH_CGET), HAS(methods, METH_CGETALL))) {
+	Tcl_AppendResult(interp,
+		"'cgetall' not supported, but should be, as 'cget' is", NULL);
 	goto error;
     }
 
-    if (!IMPLIES (HAS(methods,METH_CGETALL),HAS(methods,METH_CGET))) {
-        Tcl_AppendResult (interp, "'cget' not supported, but should be, as 'cgetall' is",
-			  (char*) NULL);
+    if (!IMPLIES(HAS(methods, METH_CGETALL), HAS(methods, METH_CGET))) {
+	Tcl_AppendResult(interp,
+		"'cget' not supported, but should be, as 'cgetall' is", NULL);
 	goto error;
     }
 
-    Tcl_ResetResult (interp);
+    Tcl_ResetResult(interp);
 
-    /* Everything is fine now */
+    /*
+     * Everything is fine now.
+     */
 
     rcPtr->methods = methods;
 
     if ((methods & NULLABLE_METHODS) != NULLABLE_METHODS) {
-        /* Some of the nullable methods are not supported.  We clone
-	 * the channel type, null the associated C functions, and use
-	 * the result as the actual channel type.
+	/*
+	 * Some of the nullable methods are not supported. We clone the
+	 * channel type, null the associated C functions, and use the result
+	 * as the actual channel type.
 	 */
 
-        Tcl_ChannelType* clonePtr = (Tcl_ChannelType*) ckalloc (sizeof (Tcl_ChannelType));
-	if (clonePtr == (Tcl_ChannelType*) NULL) {
-	    Tcl_Panic ("Out of memory in Tcl_RcCreate");
-	}
+	Tcl_ChannelType *clonePtr = (Tcl_ChannelType *)
+		ckalloc(sizeof(Tcl_ChannelType));
 
-	memcpy (clonePtr, &tclRChannelType, sizeof (Tcl_ChannelType));
+	memcpy(clonePtr, &tclRChannelType, sizeof(Tcl_ChannelType));
 
-	if (!(methods & FLAG (METH_CONFIGURE))) {
-	  clonePtr->setOptionProc = NULL;
+	if (!(methods & FLAG(METH_CONFIGURE))) {
+	    clonePtr->setOptionProc = NULL;
 	}
 
-	if (
-	    !(methods & FLAG (METH_CGET)) &&
-	    !(methods & FLAG (METH_CGETALL))
-	    ) {
+	if (!(methods & FLAG(METH_CGET)) && !(methods & FLAG(METH_CGETALL))) {
 	    clonePtr->getOptionProc = NULL;
 	}
-	if (!(methods & FLAG (METH_BLOCKING))) {
+	if (!(methods & FLAG(METH_BLOCKING))) {
 	    clonePtr->blockModeProc = NULL;
 	}
-	if (!(methods & FLAG (METH_SEEK))) {
-	    clonePtr->seekProc     = NULL;
+	if (!(methods & FLAG(METH_SEEK))) {
+	    clonePtr->seekProc = NULL;
 	    clonePtr->wideSeekProc = NULL;
 	}
 
 	chanPtr->typePtr = clonePtr;
     }
 
-    Tcl_RegisterChannel (interp, chan);
+    Tcl_RegisterChannel(interp, chan);
 
-    /* Return handle as result of command */
+    /*
+     * Return handle as result of command.
+     */
 
-    Tcl_SetObjResult (interp, rcId);
+    Tcl_SetObjResult(interp, rcId);
     return TCL_OK;
 
  error:
-    /* Signal to RcClose to not call 'finalize' */
+    /*
+     * Signal to ReflectClose to not call 'finalize'.
+     */
     rcPtr->methods = 0;
-    Tcl_Close (interp, chan);
+    Tcl_Close(interp, chan);
     return TCL_ERROR;
 
 #undef MODE
@@ -707,190 +679,198 @@ TclChanCreateObjCmd (/*ignored*/ clientData, interp, objc, objv)
  *
  * TclChanPostEventObjCmd --
  *
- *	This procedure is invoked to process the "chan postevent"
- *	Tcl command. See the user documentation for details on what it does.
+ *	This function is invoked to process the "chan postevent" Tcl command.
+ *	See the user documentation for details on what it does.
  *
  * Results:
  *	A standard Tcl result.
  *
  * Side effects:
- *	Posts events to a reflected channel, invokes event handlers.
- *	The latter implies that arbitrary side effects are possible.
+ *	Posts events to a reflected channel, invokes event handlers. The
+ *	latter implies that arbitrary side effects are possible.
  *
  *----------------------------------------------------------------------
  */
 
 int
-TclChanPostEventObjCmd (/*ignored*/ clientData, interp, objc, objv)
-     ClientData      clientData;
-     Tcl_Interp*     interp;
-     int             objc;
-     Tcl_Obj* CONST* objv;
+TclChanPostEventObjCmd(
+    ClientData clientData,
+    Tcl_Interp *interp,
+    int objc,
+    Tcl_Obj *CONST *objv)
 {
-    /* Syntax:   chan postevent CHANNEL EVENTSPEC
+    /*
+     * Syntax:   chan postevent CHANNEL EVENTSPEC
      *           [0]  [1]       [2]     [3]
      *
      * Actually: rPostevent CHANNEL EVENTSPEC
      *           [0]        [1]     [2]
      *
-     *         where EVENTSPEC = {read write ...} (Abbreviations allowed as well.
+     * where EVENTSPEC = {read write ...} (Abbreviations allowed as well).
      */
 
-#define CHAN  (1)
-#define EVENT (2)
+#define CHAN	(1)
+#define EVENT	(2)
 
-    CONST char*        chanId;      /* Tcl level channel handle */
-    Tcl_Channel        chan;        /* Channel associated to the handle */
-    Tcl_ChannelType*   chanTypePtr; /* Its associated driver structure */
-    ReflectingChannel* rcPtr;       /* Associated instance data */
-    int                mode;        /* Dummy, r|w mode of the channel */
-    int                events;      /* Mask of events to post */
+    CONST char *chanId;		/* Tcl level channel handle */
+    Tcl_Channel chan;		/* Channel associated to the handle */
+    Tcl_ChannelType *chanTypePtr;
+				/* Its associated driver structure */
+    ReflectedChannel *rcPtr;	/* Associated instance data */
+    int mode;			/* Dummy, r|w mode of the channel */
+    int events;			/* Mask of events to post */
 
-    /* Number of arguments ... */
+    /*
+     * Number of arguments...
+     */
 
     if (objc != 3) {
-        Tcl_WrongNumArgs(interp, 1, objv, "channel eventspec");
+	Tcl_WrongNumArgs(interp, 1, objv, "channel eventspec");
 	return TCL_ERROR;
     }
 
-    /* First argument is a channel, a reflected channel, and the call
-     * of this command is done from the interp defining the channel
-     * handler cmd.
+    /*
+     * First argument is a channel, a reflected channel, and the call of this
+     * command is done from the interp defining the channel handler cmd.
      */
 
-    chanId = Tcl_GetString (objv [CHAN]);
-    chan   = Tcl_GetChannel(interp, chanId, &mode);
+    chanId = TclGetString(objv[CHAN]);
+    chan = Tcl_GetChannel(interp, chanId, &mode);
 
-    if (chan == (Tcl_Channel) NULL) {
-        return TCL_ERROR;
+    if (chan == NULL) {
+	return TCL_ERROR;
     }
 
-    chanTypePtr = Tcl_GetChannelType (chan);
+    chanTypePtr = Tcl_GetChannelType(chan);
 
-    /* We use a function referenced by the channel type as our cookie
-     * to detect calls to non-reflecting channels. The channel type
-     * itself is not suitable, as it might not be the static
-     * definition in this file, but a clone thereof. And while we have
-     * reserved the name of the type nothing in the core checks
-     * against violation, so someone else might have created a channel
-     * type using our name, clashing with ourselves.
+    /*
+     * We use a function referenced by the channel type as our cookie to
+     * detect calls to non-reflecting channels. The channel type itself is not
+     * suitable, as it might not be the static definition in this file, but a
+     * clone thereof. And while we have reserved the name of the type nothing
+     * in the core checks against violation, so someone else might have
+     * created a channel type using our name, clashing with ourselves.
      */
 
-    if (chanTypePtr->watchProc != &RcWatch) {
-        Tcl_AppendResult(interp, "channel \"", chanId,
-			 "\" is not a reflected channel",
-			 (char *) NULL);
+    if (chanTypePtr->watchProc != &ReflectWatch) {
+	Tcl_AppendResult(interp, "channel \"", chanId,
+		"\" is not a reflected channel", NULL);
 	return TCL_ERROR;
     }
 
-    rcPtr = (ReflectingChannel*) Tcl_GetChannelInstanceData (chan);
+    rcPtr = (ReflectedChannel *) Tcl_GetChannelInstanceData(chan);
 
     if (rcPtr->interp != interp) {
-        Tcl_AppendResult(interp, "postevent for channel \"", chanId,
-			 "\" called from outside interpreter",
-			 (char *) NULL);
+	Tcl_AppendResult(interp, "postevent for channel \"", chanId,
+		"\" called from outside interpreter", NULL);
 	return TCL_ERROR;
     }
 
-    /* Second argument is a list of events. Allowed entries are
-     * "read", "write". Expect at least one list element.
-     * Abbreviations are ok.
+    /*
+     * Second argument is a list of events. Allowed entries are "read",
+     * "write". Expect at least one list element. Abbreviations are ok.
      */
 
-    if (RcEncodeEventMask (interp, "event", objv [EVENT], &events) != TCL_OK) {
-        return TCL_ERROR;
+    if (EncodeEventMask(interp, "event", objv[EVENT], &events) != TCL_OK) {
+	return TCL_ERROR;
     }
-    
-    /* Check that the channel is actually interested in the provided
-     * events.
+
+    /*
+     * Check that the channel is actually interested in the provided events.
      */
 
     if (events & ~rcPtr->interest) {
-        Tcl_AppendResult(interp, "tried to post events channel \"", chanId,
-			 "\" is not interested in",
-			 (char *) NULL);
+	Tcl_AppendResult(interp, "tried to post events channel \"", chanId,
+		"\" is not interested in", NULL);
 	return TCL_ERROR;
     }
 
-    /* We have the channel and the events to post.
+    /*
+     * We have the channel and the events to post.
      */
 
-    Tcl_NotifyChannel (chan, events);
+    Tcl_NotifyChannel(chan, events);
 
-    /* Squash interp results left by the event script.
+    /*
+     * Squash interp results left by the event script.
      */
 
-    Tcl_ResetResult (interp);
+    Tcl_ResetResult(interp);
     return TCL_OK;
 
 #undef CHAN
 #undef EVENT
 }
 
+/*
+ * Channel error message marshalling utilities.
+ */
 
 static Tcl_Obj*
-RcErrorMarshall (interp)
-     Tcl_Interp *interp;
+MarshallError(
+    Tcl_Interp *interp)
 {
-    /* Capture the result status of the interpreter into a string.
-     * => List of options and values, followed by the error message.
-     * The result has refCount 0.
+    /*
+     * Capture the result status of the interpreter into a string. => List of
+     * options and values, followed by the error message. The result has
+     * refCount 0.
      */
-    
-    Tcl_Obj* returnOpt = Tcl_GetReturnOptions (interp, TCL_ERROR);
 
-    /* => returnOpt.refCount == 0. We can append directly.
+    Tcl_Obj *returnOpt = Tcl_GetReturnOptions(interp, TCL_ERROR);
+
+    /*
+     * => returnOpt.refCount == 0. We can append directly.
      */
 
-    Tcl_ListObjAppendElement (NULL, returnOpt, Tcl_GetObjResult (interp));
+    Tcl_ListObjAppendElement(NULL, returnOpt, Tcl_GetObjResult(interp));
     return returnOpt;
 }
 
 static void
-RcErrorReturn (interp, msg)
-     Tcl_Interp *interp;
-     Tcl_Obj    *msg;
+UnmarshallErrorResult(
+    Tcl_Interp *interp,
+    Tcl_Obj *msgObj)
 {
-    int       res;
-    int       lc;
-    Tcl_Obj** lv;
-    int       explicitResult;
-    int       numOptions;
+    int lc;
+    Tcl_Obj **lv;
+    int explicitResult;
+    int numOptions;
 
-    /* Process the caught message.
+    /*
+     * Process the caught message.
      *
      * Syntax = (option value)... ?message?
      *
-     * Bad syntax causes a panic. Because the other side uses
+     * Bad syntax causes a panic. This is OK because the other side uses
      * Tcl_GetReturnOptions and list construction functions to marshall the
-     * information.
+     * information; if we panic here, something has gone badly wrong already.
      */
 
-    res = Tcl_ListObjGetElements (interp, msg, &lc, &lv);
-    if (res != TCL_OK) {
-	Tcl_Panic ("TclChanCaughtErrorBypass: Bad syntax of caught result");
+    if (Tcl_ListObjGetElements(interp, msgObj, &lc, &lv) != TCL_OK) {
+	Tcl_Panic("TclChanCaughtErrorBypass: Bad syntax of caught result");
     }
 
-    explicitResult = (1 == (lc % 2));
-    numOptions     = lc - explicitResult;
+    explicitResult = lc & 1;		/* Odd number of values? */
+    numOptions = lc - explicitResult;
 
     if (explicitResult) {
-	Tcl_SetObjResult (interp, lv [lc-1]);
+	Tcl_SetObjResult(interp, lv[lc-1]);
     }
 
-    (void) Tcl_SetReturnOptions(interp, Tcl_NewListObj (numOptions, lv));
+    (void) Tcl_SetReturnOptions(interp, Tcl_NewListObj(numOptions, lv));
 }
 
 int
-TclChanCaughtErrorBypass (interp, chan)
-     Tcl_Interp *interp;
-     Tcl_Channel chan;
+TclChanCaughtErrorBypass(
+    Tcl_Interp *interp,
+    Tcl_Channel chan)
 {
-    Tcl_Obj* msgc = NULL;
-    Tcl_Obj* msgi = NULL;
-    Tcl_Obj* msg  = NULL;
+    Tcl_Obj *chanMsgObj = NULL;
+    Tcl_Obj *interpMsgObj = NULL;
+    Tcl_Obj *msgObj = NULL;
 
-    /* Get a bypassed error message from channel and/or interpreter, save the
+    /*
+     * Get a bypassed error message from channel and/or interpreter, save the
      * reference, then kill the returned objects, if there were any. If there
      * are messages in both the channel has preference.
      */
@@ -900,37 +880,39 @@ TclChanCaughtErrorBypass (interp, chan)
     }
 
     if (chan != NULL) {
-	Tcl_GetChannelError       (chan,   &msgc);
+	Tcl_GetChannelError(chan, &chanMsgObj);
     }
     if (interp != NULL) {
-	Tcl_GetChannelErrorInterp (interp, &msgi);
+	Tcl_GetChannelErrorInterp(interp, &interpMsgObj);
     }
 
-    if (msgc != NULL) {
-	msg = msgc;
-	Tcl_IncrRefCount (msg);
-    } else if (msgi != NULL) {
-	msg = msgi;
-	Tcl_IncrRefCount (msg);
+    if (chanMsgObj != NULL) {
+	msgObj = chanMsgObj;
+    } else if (interpMsgObj != NULL) {
+	msg = interpMsgObj;
+    }
+    if (msgObj != NULL) {
+	Tcl_IncrRefCount(msgObj);
     }
 
-    if (msgc != NULL) {
-	Tcl_DecrRefCount (msgc);
+    if (chanMsgObj != NULL) {
+	Tcl_DecrRefCount(chanMsgObj);
     }
-    if (msgi != NULL) {
-	Tcl_DecrRefCount (msgi);
+    if (interpMsgObj != NULL) {
+	Tcl_DecrRefCount(interpMsgObj);
     }
 
-    /* No message returned, nothing caught.
+    /*
+     * No message returned, nothing caught.
      */
 
-    if (msg == NULL) {
+    if (msgObj == NULL) {
 	return 0;
     }
 
-    RcErrorReturn (interp, msg);
+    UnmarshallErrorResult(interp, msgObj);
 
-    Tcl_DecrRefCount (msg);
+    Tcl_DecrRefCount(msgObj);
     return 1;
 }
 
@@ -941,10 +923,10 @@ TclChanCaughtErrorBypass (interp, chan)
 /*
  *----------------------------------------------------------------------
  *
- * RcClose --
+ * ReflectClose --
  *
- *	This function is invoked when the channel is closed, to delete
- *	the driver specific instance data.
+ *	This function is invoked when the channel is closed, to delete the
+ *	driver specific instance data.
  *
  * Results:
  *	A posix error.
@@ -956,107 +938,106 @@ TclChanCaughtErrorBypass (interp, chan)
  */
 
 static int
-RcClose (clientData, interp)
-     ClientData  clientData;
-     Tcl_Interp* interp;
+ReflectClose(
+    ClientData clientData,
+    Tcl_Interp *interp)
 {
-    ReflectingChannel* rcPtr = (ReflectingChannel*) clientData;
-    int                res;         /* Result code for 'close' */
-    Tcl_Obj*           resObj;      /* Result data for 'close' */
-
-    if (interp == (Tcl_Interp*) NULL) {
-        /* This call comes from TclFinalizeIOSystem. There are no
-	 * interpreters, and therefore we cannot call upon the handler
-	 * command anymore. Threading is irrelevant as well.  We
-	 * simply clean up all our C level data structures and leave
-	 * the Tcl level to the other finalization functions.
+    ReflectedChannel *rcPtr = (ReflectedChannel *) clientData;
+    int result;			/* Result code for 'close' */
+    Tcl_Obj *resObj;		/* Result data for 'close' */
+
+    if (interp == NULL) {
+	/*
+	 * This call comes from TclFinalizeIOSystem. There are no
+	 * interpreters, and therefore we cannot call upon the handler command
+	 * anymore. Threading is irrelevant as well. We simply clean up all
+	 * our C level data structures and leave the Tcl level to the other
+	 * finalization functions.
 	 */
 
-      /* THREADED => Forward this to the origin thread */
-      /* Note: Have a thread delete handler for the origin
-       * thread. Use this to clean up the structure!
-       */
-
-#ifdef TCL_THREADS
-        /* Are we in the correct thread ?
+	/*
+	 * THREADED => Forward this to the origin thread
+	 *
+	 * Note: Have a thread delete handler for the origin thread. Use this
+	 * to clean up the structure!
 	 */
 
-        if (rcPtr->thread != Tcl_GetCurrentThread ()) {
-	    RcForwardParamClose p;
+#ifdef TCL_THREADS
+	if (rcPtr->thread != Tcl_GetCurrentThread()) {
+	    ForwardParam p;
 
-	    RcForwardOp (rcPtr, RcOpClose, rcPtr->thread, &p);
-	    res = p.b.code;
+	    ForwardOpToOwnerThread(rcPtr, ForwardedClose, &p);
+	    result = p.base.code;
 
-	    /* RcFree is done in the forwarded operation!,
-	     * in the other thread. rcPtr here is gone!
+	    /*
+	     * FreeReflectedChannel is done in the forwarded operation!, in
+	     * the other thread. rcPtr here is gone!
 	     */
 
-	    if (res != TCL_OK) {
-	        RcFreeReceivedError (p.b);
+	    if (result != TCL_OK) {
+		FreeReceivedError(&p);
 	    }
-	} else {
-#endif
-	    RcFree (rcPtr);
-#ifdef TCL_THREADS
+	    return EOK;
 	}
 #endif
+
+	FreeReflectedChannel(rcPtr);
 	return EOK;
     }
 
-    /* -------- */
+    /*
+     * -- No -- ASSERT rcPtr->methods & FLAG(METH_FINAL)
+     *
+     * A cleaned method mask here implies that the channel creation was
+     * aborted, and "finalize" must not be called.
+     */
 
-    /* -- No -- ASSERT rcPtr->methods & FLAG (METH_FINAL) */
+    if (rcPtr->methods == 0) {
+	FreeReflectedChannel(rcPtr);
+	return EOK;
+    }
 
-    /* A cleaned method mask here implies that the channel creation
-     * was aborted, and "finalize" must not be called.
+    /*
+     * Are we in the correct thread?
      */
 
-    if (rcPtr->methods == 0) {
-        RcFree (rcPtr);
-        return EOK;
-    } else {
 #ifdef TCL_THREADS
-        /* Are we in the correct thread ?
-	 */
+    if (rcPtr->thread != Tcl_GetCurrentThread()) {
+	ForwardParam p;
 
-        if (rcPtr->thread != Tcl_GetCurrentThread ()) {
-	    RcForwardParamClose p;
+	ForwardOpToOwnerThread(rcPtr, ForwardedClose, &p);
+	result = p.base.code;
 
-	    RcForwardOp (rcPtr, RcOpClose, rcPtr->thread, &p);
-	    res = p.b.code;
-
-	    /* RcFree is done in the forwarded operation!,
-	     * in the other thread. rcPtr here is gone!
-	     */
+	/*
+	 * FreeReflectedChannel is done in the forwarded operation!, in the
+	 * other thread. rcPtr here is gone!
+	 */
 
-	    if (res != TCL_OK) {
-	        RcPassReceivedErrorInterp (interp, p.b);
-	    }
-	} else {
+	if (result != TCL_OK) {
+	    PassReceivedErrorInterp(interp, &p);
+	}
+    } else {
 #endif
-	    RcInvokeTclMethod (rcPtr, "finalize", NULL, NULL,
-			       &res, &resObj, DO_CAPTURE);
-
-	    if ((res != TCL_OK) && (interp != NULL)) {
-	        Tcl_SetChannelErrorInterp (interp, resObj);
-	    }
+	result = InvokeTclMethod(rcPtr, "finalize", NULL, NULL, &resObj, 0);
+	if ((result != TCL_OK) && (interp != NULL)) {
+	    Tcl_SetChannelErrorInterp(interp, resObj);
+	}
 
-	    Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
+	Tcl_DecrRefCount(resObj);	/* Remove reference we held from the
+					 * invoke */
 #ifdef TCL_THREADS
-	    RcFree (rcPtr);
-	}
-#endif
-	return (res == TCL_OK) ? EOK : EINVAL;
+	FreeReflectedChannel(rcPtr);
     }
+#endif
+    return (result == TCL_OK) ? EOK : EINVAL;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * RcInput --
+ * ReflectInput --
  *
- *	This function is invoked when more data is requested from the
- *	channel.
+ *	This function is invoked when more data is requested from the channel.
  *
  * Results:
  *	The number of bytes read.
@@ -1068,69 +1049,61 @@ RcClose (clientData, interp)
  */
 
 static int
-RcInput (clientData, buf, toRead, errorCodePtr)
-     ClientData clientData;
-     char* buf;
-     int toRead;
-     int* errorCodePtr;
+ReflectInput(
+    ClientData clientData,
+    char *buf,
+    int toRead,
+    int *errorCodePtr)
 {
-    ReflectingChannel* rcPtr = (ReflectingChannel*) clientData;
-    Tcl_Obj*           toReadObj;
-    int                bytec;       /* Number of returned bytes */
-    unsigned char*     bytev;       /* Array of returned bytes */
-    int                res;         /* Result code for 'read' */
-    Tcl_Obj*           resObj;      /* Result data for 'read' */
+    ReflectedChannel *rcPtr = (ReflectedChannel *) clientData;
+    Tcl_Obj *toReadObj;
+    int bytec;			/* Number of returned bytes */
+    unsigned char *bytev;	/* Array of returned bytes */
+    Tcl_Obj *resObj;		/* Result data for 'read' */
 
-    /* The following check can be done before thread redirection,
-     * because we are reading from an item which is readonly, i.e.
-     * will never change during the lifetime of the channel.
+    /*
+     * The following check can be done before thread redirection, because we
+     * are reading from an item which is readonly, i.e. will never change
+     * during the lifetime of the channel.
      */
 
-    if (!(rcPtr->methods & FLAG (METH_READ))) {
-        RcSetChannelErrorStr (rcPtr->chan, msg_read_unsup);
+    if (!(rcPtr->methods & FLAG(METH_READ))) {
+	SetChannelErrorStr(rcPtr->chan, msg_read_unsup);
 	*errorCodePtr = EINVAL;
 	return -1;
     }
 
-#ifdef TCL_THREADS
-    /* Are we in the correct thread ?
+    /*
+     * Are we in the correct thread?
      */
 
-    if (rcPtr->thread != Tcl_GetCurrentThread ()) {
-        RcForwardParamInput p;
+#ifdef TCL_THREADS
+    if (rcPtr->thread != Tcl_GetCurrentThread()) {
+	ForwardParam p;
 
-	p.buf    = buf;
-	p.toRead = toRead;
+	p.input.buf = buf;
+	p.input.toRead = toRead;
 
-	RcForwardOp (rcPtr, RcOpInput, rcPtr->thread, &p);
+	ForwardOpToOwnerThread(rcPtr, ForwardedInput, &p);
 
-	if (p.b.code != TCL_OK) {
-	    RcPassReceivedError (rcPtr->chan, p.b);
+	if (p.base.code != TCL_OK) {
+	    PassReceivedError(rcPtr->chan, &p);
 	    *errorCodePtr = EINVAL;
 	} else {
 	    *errorCodePtr = EOK;
 	}
 
-	return p.toRead;
+	return p.input.toRead;
     }
 #endif
 
-    /* -------- */
-
-    /* ASSERT: rcPtr->method & FLAG (METH_READ) */
+    /* ASSERT: rcPtr->method & FLAG(METH_READ) */
     /* ASSERT: rcPtr->mode & TCL_READABLE */
 
     toReadObj = Tcl_NewIntObj(toRead);
-    if (toReadObj == (Tcl_Obj*) NULL) {
-        Tcl_Panic ("Out of memory in RcInput");
-    }
-
-    RcInvokeTclMethod (rcPtr, "read", toReadObj, NULL,
-		       &res, &resObj, DO_CAPTURE);
-
-    if (res != TCL_OK) {
-	Tcl_SetChannelError (rcPtr->chan, resObj);
-        Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
+    if (InvokeTclMethod(rcPtr, "read", toReadObj, NULL, &resObj, 0)!=TCL_OK) {
+	Tcl_SetChannelError(rcPtr->chan, resObj);
+	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
 	*errorCodePtr = EINVAL;
 	return -1;
     }
@@ -1138,8 +1111,8 @@ RcInput (clientData, buf, toRead, errorCodePtr)
     bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
 
     if (toRead < bytec) {
-        Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
-	RcSetChannelErrorStr (rcPtr->chan, msg_read_toomuch);
+	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
+	SetChannelErrorStr(rcPtr->chan, msg_read_toomuch);
 	*errorCodePtr = EINVAL;
 	return -1;
     }
@@ -1147,20 +1120,19 @@ RcInput (clientData, buf, toRead, errorCodePtr)
     *errorCodePtr = EOK;
 
     if (bytec > 0) {
-        memcpy (buf, bytev, bytec);
+	memcpy(buf, bytev, bytec);
     }
 
-    Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
+    Tcl_DecrRefCount(resObj);		/* Remove reference held from invoke */
     return bytec;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * RcOutput --
+ * ReflectOutput --
  *
- *	This function is invoked when data is writen to the
- *	channel.
+ *	This function is invoked when data is writen to the channel.
  *
  * Results:
  *	The number of bytes actually written.
@@ -1172,90 +1144,81 @@ RcInput (clientData, buf, toRead, errorCodePtr)
  */
 
 static int
-RcOutput (clientData, buf, toWrite, errorCodePtr)
-     ClientData clientData;
-     CONST char* buf;
-     int toWrite;
-     int* errorCodePtr;
+ReflectOutput(
+    ClientData clientData,
+    CONST char *buf,
+    int toWrite,
+    int *errorCodePtr)
 {
-    ReflectingChannel* rcPtr = (ReflectingChannel*) clientData;
-    Tcl_Obj*       bufObj;
-    int            res;         /* Result code for 'write' */
-    Tcl_Obj*       resObj;      /* Result data for 'write' */
-    int            written;
+    ReflectedChannel *rcPtr = (ReflectedChannel *) clientData;
+    Tcl_Obj *bufObj;
+    Tcl_Obj *resObj;		/* Result data for 'write' */
+    int written;
 
-    /* The following check can be done before thread redirection,
-     * because we are reading from an item which is readonly, i.e.
-     * will never change during the lifetime of the channel.
+    /*
+     * The following check can be done before thread redirection, because we
+     * are reading from an item which is readonly, i.e. will never change
+     * during the lifetime of the channel.
      */
 
-    if (!(rcPtr->methods & FLAG (METH_WRITE))) {
-        RcSetChannelErrorStr (rcPtr->chan, msg_write_unsup);
-        *errorCodePtr = EINVAL;
+    if (!(rcPtr->methods & FLAG(METH_WRITE))) {
+	SetChannelErrorStr(rcPtr->chan, msg_write_unsup);
+	*errorCodePtr = EINVAL;
 	return -1;
     }
 
-#ifdef TCL_THREADS
-    /* Are we in the correct thread ?
+    /*
+     * Are we in the correct thread?
      */
 
-    if (rcPtr->thread != Tcl_GetCurrentThread ()) {
-      RcForwardParamOutput p;
+#ifdef TCL_THREADS
+    if (rcPtr->thread != Tcl_GetCurrentThread()) {
+	ForwardParam p;
 
-      p.buf     = buf;
-      p.toWrite = toWrite;
+	p.output.buf = buf;
+	p.output.toWrite = toWrite;
 
-      RcForwardOp (rcPtr, RcOpOutput, rcPtr->thread, &p);
+	ForwardOpToOwnerThread(rcPtr, ForwardedOutput, &p);
 
-      if (p.b.code != TCL_OK) {
-	  RcPassReceivedError (rcPtr->chan, p.b);
-	  *errorCodePtr = EINVAL;
-      } else {
-	  *errorCodePtr = EOK;
-      }
+	if (p.base.code != TCL_OK) {
+	    PassReceivedError(rcPtr->chan, &p);
+	    *errorCodePtr = EINVAL;
+	} else {
+	    *errorCodePtr = EOK;
+	}
 
-      return p.toWrite;
+	return p.output.toWrite;
     }
 #endif
 
-    /* -------- */
-
-    /* ASSERT: rcPtr->method & FLAG (METH_WRITE) */
+    /* ASSERT: rcPtr->method & FLAG(METH_WRITE) */
     /* ASSERT: rcPtr->mode & TCL_WRITABLE */
-    
-    bufObj = Tcl_NewByteArrayObj((unsigned char*) buf, toWrite);
-    if (bufObj == (Tcl_Obj*) NULL) {
-        Tcl_Panic ("Out of memory in RcOutput");
-    }
 
-    RcInvokeTclMethod (rcPtr, "write", bufObj, NULL,
-		       &res, &resObj, DO_CAPTURE);
-
-    if (res != TCL_OK) {
-	Tcl_SetChannelError (rcPtr->chan, resObj);
-	Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
+    bufObj = Tcl_NewByteArrayObj((unsigned char *) buf, toWrite);
+    if (InvokeTclMethod(rcPtr, "write", bufObj, NULL, &resObj, 0) != TCL_OK) {
+	Tcl_SetChannelError(rcPtr->chan, resObj);
+	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
 	*errorCodePtr = EINVAL;
 	return -1;
     }
 
-    res = Tcl_GetIntFromObj (rcPtr->interp, resObj, &written);
-    if (res != TCL_OK) {
-        Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
-	Tcl_SetChannelError (rcPtr->chan, RcErrorMarshall (rcPtr->interp));
+    if (Tcl_GetIntFromObj(rcPtr->interp, resObj, &written) != TCL_OK) {
+	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
+	Tcl_SetChannelError(rcPtr->chan, MarshallError(rcPtr->interp));
 	*errorCodePtr = EINVAL;
 	return -1;
     }
 
-    Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
+    Tcl_DecrRefCount(resObj);		/* Remove reference held from invoke */
 
     if ((written == 0) || (toWrite < written)) {
-        /* The handler claims to have written more than it was given.
-	 * That is bad. Note that the I/O core would crash if we were
-	 * to return this information, trying to write -nnn bytes in
-	 * the next iteration.
+	/*
+	 * The handler claims to have written more than it was given. That is
+	 * bad. Note that the I/O core would crash if we were to return this
+	 * information, trying to write -nnn bytes in the next iteration.
 	 */
 
-        RcSetChannelErrorStr (rcPtr->chan, msg_write_toomuch);
+	SetChannelErrorStr(rcPtr->chan, msg_write_toomuch);
 	*errorCodePtr = EINVAL;
 	return -1;
     }
@@ -1267,10 +1230,9 @@ RcOutput (clientData, buf, toWrite, errorCodePtr)
 /*
  *----------------------------------------------------------------------
  *
- * RcSeekWide / RcSeek --
+ * ReflectSeekWide / ReflectSeek --
  *
- *	This function is invoked when the user wishes to seek on
- *	the channel.
+ *	This function is invoked when the user wishes to seek on the channel.
  *
  * Results:
  *	The new location of the access point.
@@ -1282,84 +1244,66 @@ RcOutput (clientData, buf, toWrite, errorCodePtr)
  */
 
 static Tcl_WideInt
-RcSeekWide (clientData, offset, seekMode, errorCodePtr)
-     ClientData  clientData;
-     Tcl_WideInt offset;
-     int         seekMode;
-     int*        errorCodePtr;
+ReflectSeekWide(
+    ClientData clientData,
+    Tcl_WideInt offset,
+    int seekMode,
+    int *errorCodePtr)
 {
-    ReflectingChannel* rcPtr = (ReflectingChannel*) clientData;
-    Tcl_Obj*       offObj;
-    Tcl_Obj*       baseObj;
-    int            res;         /* Result code for 'seek' */
-    Tcl_Obj*       resObj;      /* Result data for 'seek' */
-    Tcl_WideInt    newLoc;
+    ReflectedChannel *rcPtr = (ReflectedChannel *) clientData;
+    Tcl_Obj *offObj;
+    Tcl_Obj *baseObj;
+    Tcl_Obj *resObj;		/* Result for 'seek' */
+    Tcl_WideInt newLoc;
 
-#ifdef TCL_THREADS
-    /* Are we in the correct thread ?
+    /*
+     * Are we in the correct thread?
      */
 
-    if (rcPtr->thread != Tcl_GetCurrentThread ()) {
-        RcForwardParamSeek p;
+#ifdef TCL_THREADS
+    if (rcPtr->thread != Tcl_GetCurrentThread()) {
+	ForwardParam p;
 
-	p.seekMode = seekMode;
-	p.offset   = offset;
+	p.seek.seekMode = seekMode;
+	p.seek.offset = offset;
 
-	RcForwardOp (rcPtr, RcOpSeek, rcPtr->thread, &p);
+	ForwardOpToOwnerThread(rcPtr, ForwardedSeek, &p);
 
-	if (p.b.code != TCL_OK) {
-	    RcPassReceivedError (rcPtr->chan, p.b);
+	if (p.base.code != TCL_OK) {
+	    PassReceivedError(rcPtr->chan, &p);
 	    *errorCodePtr = EINVAL;
 	} else {
 	    *errorCodePtr = EOK;
 	}
 
-	return p.offset;
+	return p.seek.offset;
     }
 #endif
 
-    /* -------- */
-
-    /* ASSERT: rcPtr->method & FLAG (METH_SEEK) */
+    /* ASSERT: rcPtr->method & FLAG(METH_SEEK) */
 
     offObj = Tcl_NewWideIntObj(offset);
-    if (offObj == (Tcl_Obj*) NULL) {
-        Tcl_Panic ("Out of memory in RcSeekWide");
-    }
-
-    baseObj = Tcl_NewStringObj((seekMode == SEEK_SET) ?
-			       "start" :
-			       ((seekMode == SEEK_CUR) ?
-				"current" :
-				"end"), -1);
-
-    if (baseObj == (Tcl_Obj*) NULL) {
-        Tcl_Panic ("Out of memory in RcSeekWide");
-    }
-
-    RcInvokeTclMethod (rcPtr, "seek", offObj, baseObj,
-		       &res, &resObj, DO_CAPTURE);
-
-    if (res != TCL_OK) {
-	Tcl_SetChannelError (rcPtr->chan, resObj);
-        Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
+    baseObj = Tcl_NewStringObj((seekMode == SEEK_SET) ? "start" :
+	    ((seekMode == SEEK_CUR) ? "current" : "end"), -1);
+    if (InvokeTclMethod(rcPtr, "seek", offObj, baseObj, &resObj, 0)!=TCL_OK) {
+	Tcl_SetChannelError(rcPtr->chan, resObj);
+	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
 	*errorCodePtr = EINVAL;
 	return -1;
     }
 
-    res = Tcl_GetWideIntFromObj (rcPtr->interp, resObj, &newLoc);
-    if (res != TCL_OK) {
-        Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
-	Tcl_SetChannelError (rcPtr->chan, RcErrorMarshall (rcPtr->interp));
+    if (Tcl_GetWideIntFromObj(rcPtr->interp, resObj, &newLoc) != TCL_OK) {
+	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
+	Tcl_SetChannelError(rcPtr->chan, MarshallError(rcPtr->interp));
 	*errorCodePtr = EINVAL;
 	return -1;
     }
 
-    Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
+    Tcl_DecrRefCount(resObj);		/* Remove reference held from invoke */
 
-    if (newLoc < Tcl_LongAsWide (0)) {
-        RcSetChannelErrorStr (rcPtr->chan, msg_seek_beforestart);
-        *errorCodePtr = EINVAL;
+    if (newLoc < Tcl_LongAsWide(0)) {
+	SetChannelErrorStr(rcPtr->chan, msg_seek_beforestart);
+	*errorCodePtr = EINVAL;
 	return -1;
     }
 
@@ -1368,29 +1312,30 @@ RcSeekWide (clientData, offset, seekMode, errorCodePtr)
 }
 
 static int
-RcSeek (clientData, offset, seekMode, errorCodePtr)
-     ClientData  clientData;
-     long        offset;
-     int         seekMode;
-     int*        errorCodePtr;
+ReflectSeek(
+    ClientData clientData,
+    long offset,
+    int seekMode,
+    int *errorCodePtr)
 {
-  /* This function can be invoked from a transformation which is based
-   * on standard seeking, i.e. non-wide. Because o this we have to
-   * implement it, a dummy is not enough. We simply delegate the call
-   * to the wide routine.
-   */
-
-  return (int) RcSeekWide (clientData, Tcl_LongAsWide (offset),
-			   seekMode, errorCodePtr);
+    /*
+     * This function can be invoked from a transformation which is based on
+     * standard seeking, i.e. non-wide. Because of this we have to implement
+     * it, a dummy is not enough. We simply delegate the call to the wide
+     * routine.
+     */
+
+    return (int) ReflectSeekWide(clientData, Tcl_LongAsWide(offset), seekMode,
+	    errorCodePtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * RcWatch --
+ * ReflectWatch --
  *
- *	This function is invoked to tell the channel what events
- *	the I/O system is interested in.
+ *	This function is invoked to tell the channel what events the I/O
+ *	system is interested in.
  *
  * Results:
  *	None.
@@ -1402,62 +1347,66 @@ RcSeek (clientData, offset, seekMode, errorCodePtr)
  */
 
 static void
-RcWatch (clientData, mask)
-     ClientData clientData;
-     int mask;
+ReflectWatch(
+    ClientData clientData,
+    int mask)
 {
-    ReflectingChannel* rcPtr = (ReflectingChannel*) clientData;
-    Tcl_Obj* maskObj;
+    ReflectedChannel *rcPtr = (ReflectedChannel *) clientData;
+    Tcl_Obj *maskObj;
 
-    /* ASSERT rcPtr->methods & FLAG (METH_WATCH) */
+    /* ASSERT rcPtr->methods & FLAG(METH_WATCH) */
 
-    /* We restrict the interest to what the channel can support
-     * IOW there will never be write events for a channel which is
-     * not writable. Analoguous for read events.
+    /*
+     * We restrict the interest to what the channel can support. IOW there
+     * will never be write events for a channel which is not writable.
+     * Analoguously for read events and non-readable channels.
      */
 
-    mask = mask & rcPtr->mode; 
+    mask &= rcPtr->mode;
 
     if (mask == rcPtr->interest) {
-        /* Same old, same old, why should we do something ? */
-      return;
+	/*
+	 * Same old, same old, why should we do something?
+	 */
+
+	return;
     }
 
     rcPtr->interest = mask;
 
-#ifdef TCL_THREADS
-    /* Are we in the correct thread ?
+    /*
+     * Are we in the correct thread?
      */
 
-    if (rcPtr->thread != Tcl_GetCurrentThread ()) {
-        RcForwardParamWatch p;
-
-	p.mask = mask;
+#ifdef TCL_THREADS
+    if (rcPtr->thread != Tcl_GetCurrentThread()) {
+	ForwardParam p;
 
-	RcForwardOp (rcPtr, RcOpWatch, rcPtr->thread, &p);
+	p.watch.mask = mask;
+	ForwardOpToOwnerThread(rcPtr, ForwardedWatch, &p);
 
-	/* Any failure from the forward is ignored. We have no place to
-	 * put this.
+	/*
+	 * Any failure from the forward is ignored. We have no place to put
+	 * this.
 	 */
+
 	return;
     }
 #endif
 
-    /* -------- */
-
-    maskObj = RcDecodeEventMask (mask);
-    RcInvokeTclMethod (rcPtr, "watch", maskObj, NULL,
-		       NULL, NULL, NO_CAPTURE);
-    Tcl_DecrRefCount (maskObj);
+    maskObj = DecodeEventMask(mask);
+    (void) InvokeTclMethod(rcPtr, "watch", maskObj, NULL, NULL,
+	    INVOKE_NO_CAPTURE);
+    Tcl_DecrRefCount(maskObj);
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * RcBlock --
+ * ReflectBlock --
  *
- *	This function is invoked to tell the channel which blocking
- *	behaviour is required of it.
+ *	This function is invoked to tell the channel which blocking behaviour
+ *	is required of it.
  *
  * Results:
  *	A posix error number.
@@ -1469,60 +1418,54 @@ RcWatch (clientData, mask)
  */
 
 static int
-RcBlock (clientData, nonblocking)
-     ClientData clientData;
-     int nonblocking;
+ReflectBlock(
+    ClientData clientData,
+    int nonblocking)
 {
-    ReflectingChannel* rcPtr = (ReflectingChannel*) clientData;
-    Tcl_Obj*           blockObj;
-    int                res;         /* Result code for 'blocking' */
-    Tcl_Obj*           resObj;      /* Result data for 'blocking' */
+    ReflectedChannel *rcPtr = (ReflectedChannel *) clientData;
+    Tcl_Obj *blockObj;
+    int errorNum;		/* EINVAL or EOK (success). */
+    Tcl_Obj *resObj;		/* Result data for 'blocking' */
 
-#ifdef TCL_THREADS
-    /* Are we in the correct thread ?
+    /*
+     * Are we in the correct thread?
      */
 
-    if (rcPtr->thread != Tcl_GetCurrentThread ()) {
-        RcForwardParamBlock p;
+#ifdef TCL_THREADS
+    if (rcPtr->thread != Tcl_GetCurrentThread()) {
+	ForwardParam p;
 
-	p.nonblocking = nonblocking;
+	p.block.nonblocking = nonblocking;
 
-	RcForwardOp (rcPtr, RcOpBlock, rcPtr->thread, &p);
+	ForwardOpToOwnerThread(rcPtr, ForwardedBlock, &p);
 
-	if (p.b.code != TCL_OK) {
-	    RcPassReceivedError (rcPtr->chan, p.b);
+	if (p.base.code != TCL_OK) {
+	    PassReceivedError(rcPtr->chan, &p);
 	    return EINVAL;
-	} else {
-	    return EOK;
 	}
+
+	return EOK;
     }
 #endif
 
-    /* -------- */
-
     blockObj = Tcl_NewBooleanObj(!nonblocking);
-    if (blockObj == (Tcl_Obj*) NULL) {
-        Tcl_Panic ("Out of memory in RcBlock");
-    }
 
-    RcInvokeTclMethod (rcPtr, "blocking", blockObj, NULL,
-		       &res, &resObj, DO_CAPTURE);
-
-    if (res != TCL_OK) {
-	Tcl_SetChannelError (rcPtr->chan, resObj);
-	res = EINVAL;
+    if (InvokeTclMethod(rcPtr, "blocking", blockObj, NULL, &resObj,
+	    0) != TCL_OK) {
+	Tcl_SetChannelError(rcPtr->chan, resObj);
+	errorNum = EINVAL;
     } else {
-        res = EOK;
+	errorNum = EOK;
     }
 
-    Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
-    return res;
+    Tcl_DecrRefCount(resObj);		/* Remove reference held from invoke */
+    return errorNum;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * RcSetOption --
+ * ReflectSetOption --
  *
  *	This function is invoked to configure a channel option.
  *
@@ -1536,70 +1479,58 @@ RcBlock (clientData, nonblocking)
  */
 
 static int
-RcSetOption (clientData, interp, optionName, newValue)
-     ClientData   clientData;	/* Channel to query */
-     Tcl_Interp   *interp;	/* Interpreter to leave error messages in */
-     CONST char *optionName;	/* Name of requested option */
-     CONST char *newValue;	/* The new value */
+ReflectSetOption(
+    ClientData clientData,	/* Channel to query */
+    Tcl_Interp *interp,		/* Interpreter to leave error messages in */
+    CONST char *optionName,	/* Name of requested option */
+    CONST char *newValue)	/* The new value */
 {
-    ReflectingChannel* rcPtr = (ReflectingChannel*) clientData;
-    Tcl_Obj*           optionObj;
-    Tcl_Obj*           valueObj;
-    int                res;         /* Result code for 'configure' */
-    Tcl_Obj*           resObj;      /* Result data for 'configure' */
+    ReflectedChannel *rcPtr = (ReflectedChannel *) clientData;
+    Tcl_Obj *optionObj;
+    Tcl_Obj *valueObj;
+    int result;			/* Result code for 'configure' */
+    Tcl_Obj *resObj;		/* Result data for 'configure' */
 
-#ifdef TCL_THREADS
-    /* Are we in the correct thread ?
+    /*
+     * Are we in the correct thread?
      */
 
-    if (rcPtr->thread != Tcl_GetCurrentThread ()) {
-        RcForwardParamSetOpt p;
-
-	p.name  = optionName;
-	p.value = newValue;
+#ifdef TCL_THREADS
+    if (rcPtr->thread != Tcl_GetCurrentThread()) {
+	ForwardParam p;
 
-	RcForwardOp (rcPtr, RcOpSetOpt, rcPtr->thread, &p);
+	p.setOpt.name = optionName;
+	p.setOpt.value = newValue;
 
-	if (p.b.code != TCL_OK) {
-	    Tcl_Obj* err = Tcl_NewStringObj (p.b.msg, -1);
+	ForwardOpToOwnerThread(rcPtr, ForwardedSetOpt, &p);
 
-	    RcErrorReturn (interp, err);
+	if (p.base.code != TCL_OK) {
+	    Tcl_Obj *err = Tcl_NewStringObj(p.base.msgStr, -1);
 
-	    Tcl_DecrRefCount (err);
-	    if (p.b.vol) {ckfree (p.b.msg);}
+	    UnmarshallErrorResult(interp, err);
+	    Tcl_DecrRefCount(err);
+	    FreeReceivedError(&p);
 	}
 
-	return p.b.code;
+	return p.base.code;
     }
 #endif
 
-  /* -------- */
-
-  optionObj = Tcl_NewStringObj(optionName,-1);
-  if (optionObj == (Tcl_Obj*) NULL) {
-    Tcl_Panic ("Out of memory in RcSetOption");
-  }
-
-  valueObj = Tcl_NewStringObj(newValue,-1);
-  if (valueObj == (Tcl_Obj*) NULL) {
-    Tcl_Panic ("Out of memory in RcSetOption");
-  }
-
-  RcInvokeTclMethod (rcPtr, "configure", optionObj, valueObj,
-		     &res, &resObj, DO_CAPTURE);
-
-  if (res != TCL_OK) {
-    RcErrorReturn (interp, resObj);
-  }
+    optionObj = Tcl_NewStringObj(optionName, -1);
+    valueObj = Tcl_NewStringObj(newValue, -1);
+    result = InvokeTclMethod(rcPtr, "configure",optionObj,valueObj, &resObj,0);
+    if (result != TCL_OK) {
+	UnmarshallErrorResult(interp, resObj);
+    }
 
-  Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
-  return res;
+    Tcl_DecrRefCount(resObj);		/* Remove reference held from invoke */
+    return result;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * RcGetOption --
+ * ReflectGetOption --
  *
  *	This function is invoked to retrieve all or a channel option.
  *
@@ -1613,135 +1544,130 @@ RcSetOption (clientData, interp, optionName, newValue)
  */
 
 static int
-RcGetOption (clientData, interp, optionName, dsPtr)
-     ClientData   clientData;	/* Channel to query */
-     Tcl_Interp*  interp;	/* Interpreter to leave error messages in */
-     CONST char* optionName;	/* Name of reuqested option */
-     Tcl_DString* dsPtr;	/* String to place the result into */
+ReflectGetOption(
+    ClientData clientData,	/* Channel to query */
+    Tcl_Interp *interp,		/* Interpreter to leave error messages in */
+    CONST char *optionName,	/* Name of reuqested option */
+    Tcl_DString *dsPtr)		/* String to place the result into */
 {
-    /* This code is special. It has regular passing of Tcl result, and
-     * errors. The bypass functions are not required.
+    /*
+     * This code is special. It has regular passing of Tcl result, and errors.
+     * The bypass functions are not required.
      */
 
-    ReflectingChannel* rcPtr = (ReflectingChannel*) clientData;
-    Tcl_Obj*           optionObj;
-    int                res;         /* Result code for 'configure' */
-    Tcl_Obj*           resObj;      /* Result data for 'configure' */
-    int                listc;
-    Tcl_Obj**          listv;
-    const char*        method;
+    ReflectedChannel *rcPtr = (ReflectedChannel*) clientData;
+    Tcl_Obj *optionObj;
+    Tcl_Obj *resObj;		/* Result data for 'configure' */
+    int listc;
+    Tcl_Obj **listv;
+    const char *method;
 
-#ifdef TCL_THREADS
-    /* Are we in the correct thread ?
+    /*
+     * Are we in the correct thread?
      */
 
-    if (rcPtr->thread != Tcl_GetCurrentThread ()) {
-        int opcode;
-        RcForwardParamGetOpt p;
+#ifdef TCL_THREADS
+    if (rcPtr->thread != Tcl_GetCurrentThread()) {
+	int opcode;
+	ForwardParam p;
 
-	p.name  = optionName;
-	p.value = dsPtr;
+	p.getOpt.name = optionName;
+	p.getOpt.value = dsPtr;
 
-	if (optionName == (char*) NULL) {
-	    opcode = RcOpGetOptAll;
+	if (optionName == NULL) {
+	    opcode = ForwardedGetOptAll;
 	} else {
-	    opcode = RcOpGetOpt;
+	    opcode = ForwardedGetOpt;
 	}
 
-	RcForwardOp (rcPtr, opcode, rcPtr->thread, &p);
-
-	if (p.b.code != TCL_OK) {
-	    Tcl_Obj* err = Tcl_NewStringObj (p.b.msg, -1);
+	ForwardOpToOwnerThread(rcPtr, opcode, &p);
 
-	    RcErrorReturn (interp, err);
+	if (p.base.code != TCL_OK) {
+	    Tcl_Obj *err = Tcl_NewStringObj(p.base.msgStr, -1);
 
-	    Tcl_DecrRefCount (err);
-	    if (p.b.vol) {ckfree (p.b.msg);}
+	    UnmarshallErrorResult(interp, err);
+	    Tcl_DecrRefCount(err);
+	    FreeReceivedError(&p);
 	}
 
-	return p.b.code;
+	return p.base.code;
     }
 #endif
 
-    /* -------- */
+    if (optionName == NULL) {
+	/*
+	 * Retrieve all options.
+	 */
 
-    if (optionName == (char*) NULL) {
-        /* Retrieve all options. */
-        method    = "cgetall";
+	method = "cgetall";
 	optionObj = NULL;
     } else {
-        /* Retrieve the value of one option */
-      
-        method    = "cget";
-	optionObj = Tcl_NewStringObj(optionName,-1);
-	if (optionObj == (Tcl_Obj*) NULL) {
-	    Tcl_Panic ("Out of memory in RcGetOption");
-	}
-    }
+	/*
+	 * Retrieve the value of one option.
+	 */
 
-    RcInvokeTclMethod (rcPtr, method, optionObj, NULL,
-			 &res, &resObj, DO_CAPTURE);
+	method = "cget";
+	optionObj = Tcl_NewStringObj(optionName, -1);
+    }
 
-    if (res != TCL_OK) {
-        RcErrorReturn (interp, resObj);
-	Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
-	return res;
+    if (InvokeTclMethod(rcPtr, method, optionObj, NULL, &resObj, 0)!=TCL_OK) {
+	UnmarshallErrorResult(interp, resObj);
+	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
+	return TCL_ERROR;
     }
 
-    /* The result has to go into the 'dsPtr' for propagation to the
-     * caller of the driver.
+    /*
+     * The result has to go into the 'dsPtr' for propagation to the caller of
+     * the driver.
      */
 
     if (optionObj != NULL) {
-        Tcl_DStringAppend (dsPtr, Tcl_GetString (resObj), -1);
-	Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
-	return res;
+	Tcl_DStringAppend(dsPtr, TclGetString(resObj), -1);
+	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
+	return TCL_OK;
     }
 
-    /* Extract the list and append each item as element.
+    /*
+     * Extract the list and append each item as element.
      */
 
-    /* NOTE (4): If we extract the string rep we can assume a
-     * NOTE (4): properly quoted string. Together with a separating
-     * NOTE (4): space this way of simply appending the whole string
-     * NOTE (4): rep might be faster. It also doesn't check if the
-     * NOTE (4): result is a valid list. Nor that the list has an
-     * NOTE (4): even number elements.
-     * NOTE (4): ---
+    /*
+     * NOTE (4): If we extract the string rep we can assume a properly quoted
+     * string. Together with a separating space this way of simply appending
+     * the whole string rep might be faster. It also doesn't check if the
+     * result is a valid list. Nor that the list has an even number elements.
      */
 
-    res = Tcl_ListObjGetElements (interp, resObj, &listc, &listv);
-
-    if (res != TCL_OK) {
-        Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
-	return res;
+    if (Tcl_ListObjGetElements(interp, resObj, &listc, &listv) != TCL_OK) {
+	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
+	return TCL_ERROR;
     }
 
     if ((listc % 2) == 1) {
-        /* Odd number of elements is wrong.
+	/*
+	 * Odd number of elements is wrong.
 	 */
+
 	Tcl_Obj *objPtr = Tcl_NewObj();
+
 	Tcl_ResetResult(interp);
 	TclObjPrintf(NULL, objPtr, "Expected list with even number of "
-		"elements, got %d element%s instead", listc, 
+		"elements, got %d element%s instead", listc,
 		(listc == 1 ? "" : "s"));
 	Tcl_SetObjResult(interp, objPtr);
-	Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
+	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
 	return TCL_ERROR;
-    }
-
-
-    {
-        int len;
-	char* str = Tcl_GetStringFromObj (resObj, &len);
+    } else {
+	int len;
+	char *str = Tcl_GetStringFromObj(resObj, &len);
 
 	if (len) {
-	    Tcl_DStringAppend (dsPtr, " ", 1);
-	    Tcl_DStringAppend (dsPtr, str, len);
+	    Tcl_DStringAppend(dsPtr, " ", 1);
+	    Tcl_DStringAppend(dsPtr, str, len);
 	}
+	Tcl_DecrRefCount(resObj);	/* Remove reference held from invoke */
+	return TCL_OK;
     }
-    Tcl_DecrRefCount (resObj); /* Remove reference we held from the invoke */
-    return res;
 }
 
 /*
@@ -1751,58 +1677,60 @@ RcGetOption (clientData, interp, optionName, dsPtr)
 /*
  *----------------------------------------------------------------------
  *
- * RcEncodeEventMask --
+ * EncodeEventMask --
  *
  *	This function takes a list of event items and constructs the
- *	equivalent internal bitmask. The list has to contain at
- *	least one element. Elements are "read", "write", or any unique
- *	abbreviation thereof. Note that the bitmask is not changed if
- *	problems are encountered.
+ *	equivalent internal bitmask. The list has to contain at least one
+ *	element. Elements are "read", "write", or any unique abbreviation
+ *	thereof. Note that the bitmask is not changed if problems are
+ *	encountered.
  *
  * Results:
- *	A standard Tcl error code. A bitmask where TCL_READABLE
- *	and/or TCL_WRITABLE can be set.
+ *	A standard Tcl error code. A bitmask where TCL_READABLE and/or
+ *	TCL_WRITABLE can be set.
  *
  * Side effects:
- *	May shimmer 'obj' to a list representation. May place an
- *	error message into the interp result.
+ *	May shimmer 'obj' to a list representation. May place an error message
+ *	into the interp result.
  *
  *----------------------------------------------------------------------
  */
 
 static int
-RcEncodeEventMask (interp, objName, obj, mask)
-     Tcl_Interp* interp;
-     CONST char* objName;
-     Tcl_Obj*    obj;
-     int*        mask;
+EncodeEventMask(
+    Tcl_Interp *interp,
+    CONST char *objName,
+    Tcl_Obj *obj,
+    int *mask)
 {
-    int        events;	/* Mask of events to post */
-    int        listc;     /* #elements in eventspec list */
-    Tcl_Obj**  listv;     /* Elements of eventspec list */
-    int        evIndex;   /* Id of event for an element of the
-			 * eventspec list */
+    int events;			/* Mask of events to post */
+    int listc;			/* #elements in eventspec list */
+    Tcl_Obj **listv;		/* Elements of eventspec list */
+    int evIndex;		/* Id of event for an element of the eventspec
+				 * list. */
 
-    if (Tcl_ListObjGetElements (interp, obj,
-				&listc, &listv) != TCL_OK) {
-        return TCL_ERROR;
+    if (Tcl_ListObjGetElements(interp, obj, &listc, &listv) != TCL_OK) {
+	return TCL_ERROR;
     }
 
     if (listc < 1) {
-        Tcl_AppendResult(interp, "bad ", objName, " list: is empty",
-			 (char *) NULL);
+	Tcl_AppendResult(interp, "bad ", objName, " list: is empty", NULL);
 	return TCL_ERROR;
     }
 
     events = 0;
     while (listc > 0) {
-        if (Tcl_GetIndexFromObj (interp, listv [listc-1],
-				 eventOptions, objName, 0, &evIndex) != TCL_OK) {
+	if (Tcl_GetIndexFromObj(interp, listv[listc-1], eventOptions,
+		objName, 0, &evIndex) != TCL_OK) {
 	    return TCL_ERROR;
 	}
 	switch (evIndex) {
-	    case EVENT_READ:  events |= TCL_READABLE; break;
-	    case EVENT_WRITE: events |= TCL_WRITABLE; break;
+	case EVENT_READ:
+	    events |= TCL_READABLE;
+	    break;
+	case EVENT_WRITE:
+	    events |= TCL_WRITABLE;
+	    break;
 	}
 	listc --;
     }
@@ -1814,14 +1742,14 @@ RcEncodeEventMask (interp, objName, obj, mask)
 /*
  *----------------------------------------------------------------------
  *
- * RcDecodeEventMask --
+ * DecodeEventMask --
  *
- *	This function takes an internal bitmask of events and
- *	constructs the equivalent list of event items.
+ *	This function takes an internal bitmask of events and constructs the
+ *	equivalent list of event items.
  *
  * Results:
- *	A Tcl_Obj reference. The object will have a refCount of
- *	one. The user has to decrement it to release the object.
+ *	A Tcl_Obj reference. The object will have a refCount of one. The user
+ *	has to decrement it to release the object.
  *
  * Side effects:
  *	None.
@@ -1829,31 +1757,40 @@ RcEncodeEventMask (interp, objName, obj, mask)
  *----------------------------------------------------------------------
  */
 
-static Tcl_Obj*
-RcDecodeEventMask (mask)
-     int mask;
+static Tcl_Obj *
+DecodeEventMask(
+    int mask)
 {
-    Tcl_Obj* evObj = Tcl_NewStringObj (((mask & RANDW) == RANDW) ?
-				       "read write" :
-				       ((mask & TCL_READABLE) ?
-					"read" :
-					((mask & TCL_WRITABLE) ?
-					 "write" : "")), -1);
-    if (evObj == (Tcl_Obj*) NULL) {
-        Tcl_Panic ("Out of memory in RcDecodeEventMask");
+    register CONST char *eventStr;
+    Tcl_Obj *evObj;
+
+    switch (mask & RANDW) {
+    case RANDW:
+	eventStr = "read write";
+	break;
+    case TCL_READABLE:
+	eventStr = "read";
+	break;
+    case TCL_WRITABLE:
+	eventStr = "write";
+	break;
+    default:
+	eventStr = "";
+	break;
     }
 
-    Tcl_IncrRefCount (evObj);
+    evObj = Tcl_NewStringObj(eventStr, -1);
+    Tcl_IncrRefCount(evObj);
     return evObj;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * RcNew --
+ * NewReflectedChannel --
  *
- *	This function is invoked to allocate and initialize the
- *	instance data of a new reflected channel.
+ *	This function is invoked to allocate and initialize the instance data
+ *	of a new reflected channel.
  *
  * Results:
  *	A heap-allocated channel instance.
@@ -1864,42 +1801,44 @@ RcDecodeEventMask (mask)
  *----------------------------------------------------------------------
  */
 
-static ReflectingChannel*
-RcNew (interp, cmdpfxObj, mode, id)
-       Tcl_Interp* interp;
-       Tcl_Obj*    cmdpfxObj;
-       int         mode;
-       Tcl_Obj*    id;
+static ReflectedChannel *
+NewReflectedChannel(
+    Tcl_Interp *interp,
+    Tcl_Obj *cmdpfxObj,
+    int mode,
+    Tcl_Obj *handleObj)
 {
-    ReflectingChannel* rcPtr;
-    int                listc;
-    Tcl_Obj**          listv;
-    Tcl_Obj*           word;
-    int                i;
+    ReflectedChannel *rcPtr;
+    int listc;
+    Tcl_Obj **listv;
+    int i;
 
-    rcPtr = (ReflectingChannel*) ckalloc (sizeof(ReflectingChannel));
+    rcPtr = (ReflectedChannel *) ckalloc(sizeof(ReflectedChannel));
 
-    /* rcPtr->chan    : Assigned by caller. Dummy data here. */
-    /* rcPtr->methods : Assigned by caller. Dummy data here. */
+    /* rcPtr->chan: Assigned by caller. Dummy data here. */
+    /* rcPtr->methods: Assigned by caller. Dummy data here. */
 
-    rcPtr->chan     = (Tcl_Channel) NULL;
-    rcPtr->methods  = 0;
-    rcPtr->interp   = interp;
+    rcPtr->chan = NULL;
+    rcPtr->methods = 0;
+    rcPtr->interp = interp;
 #ifdef TCL_THREADS
-    rcPtr->thread   = Tcl_GetCurrentThread ();
+    rcPtr->thread = Tcl_GetCurrentThread();
 #endif
-    rcPtr->mode     = mode;
-    rcPtr->interest = 0; /* Initially no interest registered */
+    rcPtr->mode = mode;
+    rcPtr->interest = 0;		/* Initially no interest registered */
 
-    /* Method placeholder */
+    /*
+     * Method placeholder.
+     */
 
     /* ASSERT: cmdpfxObj is a Tcl List */
 
-    Tcl_ListObjGetElements (interp, cmdpfxObj, &listc, &listv);
+    Tcl_ListObjGetElements(interp, cmdpfxObj, &listc, &listv);
 
-    /* See [==] as well.
-     * Storage for the command prefix and the additional words required
-     * for the invocation of methods in the command handler.
+    /*
+     * See [==] as well.
+     * Storage for the command prefix and the additional words required for
+     * the invocation of methods in the command handler.
      *
      * listv [0] [listc-1] | [listc]  [listc+1] |
      * argv  [0]   ... [.] | [argc-2] [argc-1]  | [argc]  [argc+2]
@@ -1907,284 +1846,299 @@ RcNew (interp, cmdpfxObj, mode, id)
      */
 
     rcPtr->argc = listc + 2;
-    rcPtr->argv = (Tcl_Obj**) ckalloc (sizeof (Tcl_Obj*) * (listc+4));
+    rcPtr->argv = (Tcl_Obj**) ckalloc(sizeof(Tcl_Obj*) * (listc+4));
+
+    /*
+     * Duplicate object references.
+     */
 
-    for (i = 0; i < listc ; i++) {
-        word = rcPtr->argv [i] = listv [i];
-        Tcl_IncrRefCount (word);
+    for (i=0; i<listc ; i++) {
+	Tcl_Obj *word = rcPtr->argv[i] = listv[i];
+	Tcl_IncrRefCount(word);
     }
 
-    i++; /* Skip placeholder for method */
+    i++;				/* Skip placeholder for method */
+
+    rcPtr->argv[i] = handleObj;
+    Tcl_IncrRefCount(handleObj);
 
-    rcPtr->argv [i] = id ; Tcl_IncrRefCount (id);
+    /*
+     * The next two objects are kept empty, varying arguments.
+     */
 
-    /* The next two objects are kept empty, varying arguments */
+    /*
+     * Initialization complete.
+     */
 
-    /* Initialization complete */
     return rcPtr;
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * RcNewHandle --
+ * NextHandle --
  *
- *	This function is invoked to generate a channel handle for
- *	a new reflected channel.
+ *	This function is invoked to generate a channel handle for a new
+ *	reflected channel.
  *
  * Results:
- *	A Tcl_Obj containing the string of the new channel handle.
- *	The refcount of the returned object is -- zero --.
+ *	A Tcl_Obj containing the string of the new channel handle. The
+ *	refcount of the returned object is -- zero --.
  *
  * Side effects:
- *	May allocate memory. Mutex protected critical section
- *	locks out other threads for a short time.
+ *	May allocate memory. Mutex protected critical section locks out other
+ *	threads for a short time.
  *
  *----------------------------------------------------------------------
  */
 
-static Tcl_Obj*
-RcNewHandle ()
+static Tcl_Obj *
+NextHandle(void)
 {
-    /* Count number of generated reflected channels.  Used for id
-     * generation. Ids are never reclaimed and there is no dealing
-     * with wrap around. On the other hand, "unsigned long" should be
-     * big enough except for absolute longrunners (generate a 100 ids
-     * per second => overflow will occur in 1 1/3 years).
+    /*
+     * Count number of generated reflected channels. Used for id generation.
+     * Ids are never reclaimed and there is no dealing with wrap around. On
+     * the other hand, "unsigned long" should be big enough except for
+     * absolute longrunners (generate a 100 ids per second => overflow will
+     * occur in 1 1/3 years).
      */
 
-#ifdef TCL_THREADS
-    TCL_DECLARE_MUTEX (rcCounterMutex)
-#endif
+    TCL_DECLARE_MUTEX(rcCounterMutex)
     static unsigned long rcCounter = 0;
+    Tcl_Obj *resObj;
 
-    Tcl_Obj* res = Tcl_NewObj ();
-
-#ifdef TCL_THREADS
-    Tcl_MutexLock (&rcCounterMutex);
-#endif
-
-    TclObjPrintf(NULL, res, "rc%lu", rcCounter);
-    rcCounter ++;
+    TclNewObj(resObj);
+    Tcl_MutexLock(&rcCounterMutex);
+    TclObjPrintf(NULL, resObj, "rc%lu", rcCounter);
+    rcCounter++;
+    Tcl_MutexUnlock(&rcCounterMutex);
 
-#ifdef TCL_THREADS
-    Tcl_MutexUnlock (&rcCounterMutex);
-#endif
-
-    return res;
+    return resObj;
 }
 
-
 static void
-RcFree (rcPtr)
-     ReflectingChannel* rcPtr;
+FreeReflectedChannel(rcPtr)
+    ReflectedChannel *rcPtr;
 {
-    Channel* chanPtr = (Channel*) rcPtr->chan;
-    int      i, n;
+    Channel *chanPtr = (Channel *) rcPtr->chan;
+    int i, n;
 
     if (chanPtr->typePtr != &tclRChannelType) {
-        /* Delete a cloned ChannelType structure. */
-        ckfree ((char*) chanPtr->typePtr);
+	/*
+	 * Delete a cloned ChannelType structure.
+	 */
+
+	ckfree((char*) chanPtr->typePtr);
     }
 
     n = rcPtr->argc - 2;
-    for (i = 0; i < n; i++) {
-        Tcl_DecrRefCount (rcPtr->argv[i]);
+    for (i=0; i<n; i++) {
+	Tcl_DecrRefCount(rcPtr->argv[i]);
     }
 
-    ckfree ((char*) rcPtr->argv);
-    ckfree ((char*) rcPtr);
-    return;
+    ckfree((char*) rcPtr->argv);
+    ckfree((char*) rcPtr);
 }
 
 /*
  *----------------------------------------------------------------------
  *
- * RcInvokeTclMethod --
+ * InvokeTclMethod --
  *
- *	This function is used to invoke the Tcl level of a reflected
- *	channel. It handles all the command assembly, invokation, and
- *	generic state and result mgmt.
+ *	This function is used to invoke the Tcl level of a reflected channel.
+ *	It handles all the command assembly, invokation, and generic state and
+ *	result mgmt. It does *not* handle thread redirection; that is the
+ *	responsibility of clients of this function.
  *
  * Results:
- *      Result code and data as returned by the method.
+ *	Result code and data as returned by the method.
  *
  * Side effects:
- *	Arbitrary, as it calls upo na Tcl script.
+ *	Arbitrary, as it calls upon a Tcl script.
  *
  *----------------------------------------------------------------------
  */
 
-static void
-RcInvokeTclMethod (rcPtr, method, argone, argtwo, result, resultObj, capture)
-     ReflectingChannel* rcPtr;
-     CONST char*        method;
-     Tcl_Obj*           argone;    /* NULL'able */
-     Tcl_Obj*           argtwo;    /* NULL'able */
-     int*               result;    /* NULL'able */
-     Tcl_Obj**          resultObj; /* NULL'able */
-     int                capture;
+static int
+InvokeTclMethod(
+    ReflectedChannel *rcPtr;
+    CONST char *method;
+    Tcl_Obj *argOneObj;		/* NULL'able */
+    Tcl_Obj *argTwoObj;		/* NULL'able */
+    Tcl_Obj **resultObjPtr;	/* NULL'able */
+    int flags;
 {
-    /* Thread redirection was done by higher layers */
-    /* ASSERT: Tcl_GetCurrentThread () == rcPtr->thread */
-
-    int             cmdc;           /* #words in constructed command */
-    Tcl_Obj*        methObj = NULL; /* Method name in object form */
-    Tcl_InterpState sr;             /* State of handler interp */
-    int             res;            /* Result code of method invokation */
-    Tcl_Obj*        resObj  = NULL; /* Result of method invokation. */
+    int cmdc;			/* #words in constructed command */
+    Tcl_Obj *methObj = NULL;	/* Method name in object form */
+    Tcl_InterpState sr;		/* State of handler interp */
+    int result;			/* Result code of method invokation */
+    Tcl_Obj *resObj = NULL;	/* Result of method invokation. */
 
-    /* NOTE (5): Decide impl. issue: Cache objects with method names ?
-     * NOTE (5): Requires TSD data as reflections can be created in
-     * NOTE (5): many different threads.
-     * NOTE (5): ---
+    /*
+     * NOTE (5): Decide impl. issue: Cache objects with method names?
+     * Requires TSD data as reflections can be created in many different
+     * threads.
      */
 
-    /* Insert method into the pre-allocated area, after the command
-     * prefix, before the channel id.
+    /*
+     * Insert method into the pre-allocated area, after the command prefix,
+     * before the channel id.
      */
 
-    methObj = Tcl_NewStringObj (method, -1);
-    if (methObj == (Tcl_Obj*) NULL) {
-        Tcl_Panic ("Out of memory in RcInvokeTclMethod");
-    }
-    Tcl_IncrRefCount (methObj);
-    rcPtr->argv [rcPtr->argc - 2] = methObj;
+    methObj = Tcl_NewStringObj(method, -1);
+    Tcl_IncrRefCount(methObj);
+    rcPtr->argv[rcPtr->argc - 2] = methObj;
 
-    /* Append the additional argument containing method specific
-     * details behind the channel id. If specified.
+    /*
+     * Append the additional argument containing method specific details
+     * behind the channel id. If specified.
      */
 
-    cmdc = rcPtr->argc ;
-    if (argone) {
-        Tcl_IncrRefCount (argone);
-	rcPtr->argv [cmdc] = argone;
-	cmdc++;
-    }
-    if (argtwo) {
-        Tcl_IncrRefCount (argtwo);
-	rcPtr->argv [cmdc] = argtwo;
+    cmdc = rcPtr->argc;
+    if (argOneObj) {
+	Tcl_IncrRefCount(argOneObj);
+	rcPtr->argv[cmdc] = argOneObj;
 	cmdc++;
+	if (argTwoObj) {
+	    Tcl_IncrRefCount(argTwoObj);
+	    rcPtr->argv[cmdc] = argTwoObj;
+	    cmdc++;
+	}
     }
 
-    /* And run the handler ...  This is done in auch a manner which
-     * leaves any existing state intact.
+    /*
+     * And run the handler... This is done in auch a manner which leaves any
+     * existing state intact.
      */
 
-    sr  = Tcl_SaveInterpState (rcPtr->interp, 0 /* Dummy */);
-    res = Tcl_EvalObjv        (rcPtr->interp, cmdc, rcPtr->argv, TCL_EVAL_GLOBAL);
+    sr = Tcl_SaveInterpState(rcPtr->interp, 0 /* Dummy */);
+    Tcl_Preserve(rcPtr->interp);
+    result = Tcl_EvalObjv(rcPtr->interp, cmdc, rcPtr->argv, TCL_EVAL_GLOBAL);
 
-    /* We do not try to extract the result information if the caller has no
+    /*
+     * We do not try to extract the result information if the caller has no
      * interest in it. I.e. there is no need to put effort into creating
      * something which is discarded immediately after.
      */
 
-    if (resultObj) {
-	if ((res == TCL_OK) || !capture) {
-	    /* Ok result taken as is, also if the caller requests that there
+    if (resultObjPtr) {
+	if ((result == TCL_OK) || (flags & INVOKE_NO_CAPTURE)) {
+	    /*
+	     * Ok result taken as is, also if the caller requests that there
 	     * is no capture.
 	     */
 
-	    resObj = Tcl_GetObjResult (rcPtr->interp);
+	    resObj = Tcl_GetObjResult(rcPtr->interp);
 	} else {
-	    /* Non-ok ressult is always treated as an error.
-	     * We have to capture the full state of the result,
-	     * including additional options.
+	    /*
+	     * Non-ok result is always treated as an error. We have to capture
+	     * the full state of the result, including additional options.
 	     */
 
-	    res    = TCL_ERROR;
-	    resObj = RcErrorMarshall (rcPtr->interp);
+	    result = TCL_ERROR;
+	    resObj = MarshallError(rcPtr->interp);
 	}
 	Tcl_IncrRefCount(resObj);
     }
-    Tcl_RestoreInterpState (rcPtr->interp, sr);
-
-    /* ... */
+    Tcl_RestoreInterpState(rcPtr->interp, sr);
+    Tcl_Release(rcPtr->interp);
 
-    /* Cleanup of the dynamic parts of the command */
+    /*
+     * Cleanup of the dynamic parts of the command.
+     */
 
-    Tcl_DecrRefCount (methObj);
-    if (argone) {Tcl_DecrRefCount (argone);}
-    if (argtwo) {Tcl_DecrRefCount (argtwo);}
+    Tcl_DecrRefCount(methObj);
+    if (argOneObj) {
+	Tcl_DecrRefCount(argOneObj);
+	if (argTwoObj) {
+	    Tcl_DecrRefCount(argTwoObj);
+	}
+    }
 
-    /* The resObj has a ref count of 1 at this location.  This means
-     * that the caller of RcInvoke has to dispose of it (but only if
-     * it was returned to it).
+    /*
+     * The resObj has a ref count of 1 at this location. This means that the
+     * caller of InvokeTclMethod has to dispose of it (but only if it was
+     * returned to it).
      */
 
-    if (result) {
-        *result = res;
-    }
-    if (resultObj) {
-        *resultObj = resObj;
+    if (resultObjPtr != NULL) {
+	*resultObjPtr = resObj;
     }
-    /* There no need to handle the case where nothing is returned, because for
+
+    /*
+     * There no need to handle the case where nothing is returned, because for
      * that case resObj was not set anyway.
      */
+
+    return result;
 }
 
 #ifdef TCL_THREADS
 static void
-RcForwardOp (rcPtr, op, dst, param)
-  ReflectingChannel* rcPtr; /* Channel instance */
-  RcOperation        op;    /* Forwarded driver operation */
-  Tcl_ThreadId       dst;   /* Destination thread */
-  CONST VOID*        param; /* Arguments */
+ForwardOpToOwnerThread(
+    ReflectedChannel *rcPtr,	/* Channel instance */
+    ForwardedOperation op,	/* Forwarded driver operation */
+    CONST VOID *param)		/* Arguments */
 {
-    RcForwardingEvent*  evPtr;
-    RcForwardingResult* resultPtr;
-    int                 result;
+    Tcl_ThreadId dst = rcPtr->thread;
+    ForwardingEvent *evPtr;
+    ForwardingResult *resultPtr;
+    int result;
 
-    /* Create and initialize the event and data structures */
+    /*
+     * Create and initialize the event and data structures.
+     */
 
-    evPtr     = (RcForwardingEvent*)  ckalloc (sizeof (RcForwardingEvent));
-    resultPtr = (RcForwardingResult*) ckalloc (sizeof (RcForwardingResult));
+    evPtr = (ForwardingEvent *) ckalloc(sizeof(ForwardingEvent));
+    resultPtr = (ForwardingResult *) ckalloc(sizeof(ForwardingResult));
 
-    evPtr->event.proc = RcForwardProc;
-    evPtr->resultPtr  = resultPtr;
-    evPtr->op         = op;
-    evPtr->rcPtr      = rcPtr;
-    evPtr->param      = param;
+    evPtr->event.proc = ForwardProc;
+    evPtr->resultPtr = resultPtr;
+    evPtr->op = op;
+    evPtr->rcPtr = rcPtr;
+    evPtr->param = param;
 
-    resultPtr->src    = Tcl_GetCurrentThread ();
-    resultPtr->dst    = dst;
-    resultPtr->done   = (Tcl_Condition) NULL;
+    resultPtr->src = Tcl_GetCurrentThread();
+    resultPtr->dst = dst;
+    resultPtr->done = NULL;
     resultPtr->result = -1;
-    resultPtr->evPtr  = evPtr;
+    resultPtr->evPtr = evPtr;
 
-    /* Now execute the forward */
+    /*
+     * Now execute the forward.
+     */
 
     Tcl_MutexLock(&rcForwardMutex);
     TclSpliceIn(resultPtr, forwardList);
 
     /*
-     * Ensure cleanup of the event if any of the two involved threads
-     * exits while this event is pending or in progress.
+     * Ensure cleanup of the event if any of the two involved threads exits
+     * while this event is pending or in progress.
      */
 
-    Tcl_CreateThreadExitHandler(RcSrcExitProc, (ClientData) evPtr);
-    Tcl_CreateThreadExitHandler(RcDstExitProc, (ClientData) evPtr);
+    Tcl_CreateThreadExitHandler(SrcExitProc, (ClientData) evPtr);
+    Tcl_CreateThreadExitHandler(DstExitProc, (ClientData) 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);
 
     /*
-     * (*) Block until the other thread has either processed the transfer
-     * or rejected it.
+     * (*) Block until the other thread has either processed the transfer or
+     * rejected it.
      */
 
     while (resultPtr->result < 0) {
-        /* NOTE (1): Is it possible that the current thread goes away while waiting here ?
-	 * NOTE (1): IOW Is it possible that "RcSrcExitProc" is called while we are here ?
-	 * NOTE (1): See complementary note (2) in "RcSrcExitProc"
-	 * NOTE (1): ---
+	/*
+	 * NOTE (1): Is it possible that the current thread goes away while
+	 * waiting here? IOW Is it possible that "SrcExitProc" is called
+	 * while we are here? See complementary note (2) in "SrcExitProc"
 	 */
 
-        Tcl_ConditionWait(&resultPtr->done, &rcForwardMutex, NULL);
+	Tcl_ConditionWait(&resultPtr->done, &rcForwardMutex, NULL);
     }
 
     /*
@@ -2193,362 +2147,294 @@ RcForwardOp (rcPtr, op, dst, param)
 
     TclSpliceOut(resultPtr, forwardList);
 
-    resultPtr->nextPtr  = NULL;
-    resultPtr->prevPtr  = NULL;
+    resultPtr->nextPtr = NULL;
+    resultPtr->prevPtr = NULL;
 
     Tcl_MutexUnlock(&rcForwardMutex);
     Tcl_ConditionFinalize(&resultPtr->done);
 
     /*
-     * Kill the cleanup handlers now, and the result structure as well,
-     * before returning the success code.
+     * Kill the cleanup handlers now, and the result structure as well, before
+     * returning the success code.
      *
      * Note: The event structure has already been deleted.
      */
 
-    Tcl_DeleteThreadExitHandler(RcSrcExitProc, (ClientData) evPtr);
-    Tcl_DeleteThreadExitHandler(RcDstExitProc, (ClientData) evPtr);
-    
-    result =  resultPtr->result;
-    ckfree ((char*) resultPtr);
+    Tcl_DeleteThreadExitHandler(SrcExitProc, (ClientData) evPtr);
+    Tcl_DeleteThreadExitHandler(DstExitProc, (ClientData) evPtr);
+
+    result = resultPtr->result;
+    ckfree((char*) resultPtr);
 }
 
 static int
-RcForwardProc (evGPtr, mask)
-     Tcl_Event *evGPtr; 
-     int mask;
+ForwardProc(
+    Tcl_Event *evGPtr,
+    int mask)
 {
-    /* Notes regarding access to the referenced data.
+    /*
+     * Notes regarding access to the referenced data.
      *
      * In principle the data belongs to the originating thread (see
-     * evPtr->src), however this thread is currently blocked at (*),
-     * i.e. quiescent. Because of this we can treat the data as
-     * belonging to us, without fear of race conditions. I.e. we can
-     * read and write as we like.
+     * evPtr->src), however this thread is currently blocked at (*), i.e.
+     * quiescent. Because of this we can treat the data as belonging to us,
+     * without fear of race conditions. I.e. we can read and write as we like.
      *
-     * The only thing we cannot be sure of is the resultPtr. This can be
-     * be NULLed if the originating thread went away while the event
-     * is handled here now.
+     * The only thing we cannot be sure of is the resultPtr. This can be be
+     * NULLed if the originating thread went away while the event is handled
+     * here now.
      */
 
-    RcForwardingEvent*  evPtr     = (RcForwardingEvent*) evGPtr;
-    RcForwardingResult* resultPtr = evPtr->resultPtr;
-    ReflectingChannel*  rcPtr     = evPtr->rcPtr;
-    Tcl_Interp*         interp    = rcPtr->interp;
-    RcForwardParamBase* paramPtr  = (RcForwardParamBase*) evPtr->param;
-    int                 res       = TCL_OK; /* Result code   of RcInvokeTclMethod */
-    Tcl_Obj*            resObj    = NULL;   /* Interp result of RcInvokeTclMethod */
+    ForwardingEvent *evPtr = (ForwardingEvent *) evGPtr;
+    ForwardingResult *resultPtr = evPtr->resultPtr;
+    ReflectedChannel *rcPtr = evPtr->rcPtr;
+    Tcl_Interp *interp = rcPtr->interp;
+    ForwardParam *paramPtr = evPtr->param;
+    Tcl_Obj *resObj = NULL;	/* Interp result of InvokeTclMethod */
 
-    /* Ignore the event if no one is waiting for its result anymore.
+    /*
+     * Ignore the event if no one is waiting for its result anymore.
      */
 
     if (!resultPtr) {
-        return 1;
+	return 1;
     }
 
     paramPtr->code = TCL_OK;
-    paramPtr->msg  = NULL;
-    paramPtr->vol  = 0;
+    paramPtr->msgStr = NULL;
+    paramPtr->mustFree = 0;
 
     switch (evPtr->op) {
-      /* The destination thread for the following operations is
-       * rcPtr->thread, which contains rcPtr->interp, the interp
-       * we have to call upon for the driver.
-       */
-
-    case RcOpClose:
-      {
-	  /* No parameters/results */
-	  RcInvokeTclMethod (rcPtr, "finalize", NULL, NULL,
-			     &res, &resObj, DO_CAPTURE);
-
-	  if (res != TCL_OK) {
-	     RcForwardSetObjError (paramPtr, resObj);
-	  }
-
-	  /* Freeing is done here, in the origin thread, because the
-	   * argv[] objects belong to this thread. Deallocating them
-	   * in a different thread is not allowed
-	   */
-
-	  RcFree (rcPtr);
-      }
-      break;
-
-    case RcOpInput:
-      {
-	  RcForwardParamInput* p = (RcForwardParamInput*) paramPtr;
-	  Tcl_Obj*     toReadObj = Tcl_NewIntObj (p->toRead);
-
-	  if (toReadObj == (Tcl_Obj*) NULL) {
-	      Tcl_Panic ("Out of memory in RcInput");
-	  }
-
-	  RcInvokeTclMethod (rcPtr, "read", toReadObj, NULL,
-			     &res, &resObj, DO_CAPTURE);
-
-	  if (res != TCL_OK) {
-	      RcForwardSetObjError (paramPtr, resObj);
-	      p->toRead = -1;
-	  } else {
-	      /* Process a regular result. */
-
-	      int            bytec; /* Number of returned bytes */
-	      unsigned char* bytev; /* Array of returned bytes */
-
-	      bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
-
-	      if (p->toRead < bytec) {
-		  RcForwardSetStaticError (paramPtr, msg_read_toomuch);
-		  p->toRead   = -1;
-
-	      } else {
-	          if (bytec > 0) {
-		      memcpy (p->buf, bytev, bytec);
-		  }
-
-		  p->toRead = bytec;
-	      }
-	  }
-      }
-      break;
-
-    case RcOpOutput:
-      {
-	  RcForwardParamOutput* p = (RcForwardParamOutput*) paramPtr;
-	  Tcl_Obj*         bufObj = Tcl_NewByteArrayObj((unsigned char*) p->buf, p->toWrite);
-
-	  if (bufObj == (Tcl_Obj*) NULL) {
-	      Tcl_Panic ("Out of memory in RcOutput");
-	  }
-
-	  RcInvokeTclMethod (rcPtr, "write", bufObj, NULL,
-			     &res, &resObj, DO_CAPTURE);
-
-	  if (res != TCL_OK) {
-	      RcForwardSetObjError (paramPtr, resObj);
-	      p->toWrite = -1;
-	  } else {
-	      /* Process a regular result. */
-
-	      int written;
-
-	      res = Tcl_GetIntFromObj (interp, resObj, &written);
-	      if (res != TCL_OK) {
-
-		  RcForwardSetObjError (paramPtr, RcErrorMarshall (interp));
-		  p->toWrite = -1;
-
-	      } else if ((written == 0) || (p->toWrite < written)) {
-
-		  RcForwardSetStaticError (paramPtr, msg_write_toomuch);
-		  p->toWrite = -1;
-
-	      } else {
-		  p->toWrite = written;
-	      }
-	  }
-      }
-      break;
-
-    case RcOpSeek:
-      {
-	  RcForwardParamSeek* p = (RcForwardParamSeek*) paramPtr;
-
-	  Tcl_Obj*       offObj;
-	  Tcl_Obj*       baseObj;
-
-	  offObj = Tcl_NewWideIntObj(p->offset);
-	  if (offObj == (Tcl_Obj*) NULL) {
-	      Tcl_Panic ("Out of memory in RcSeekWide");
-	  }
-
-	  baseObj = Tcl_NewStringObj((p->seekMode == SEEK_SET) ?
-				     "start" :
-				     ((p->seekMode == SEEK_CUR) ?
-				      "current" :
-				      "end"), -1);
-
-	  if (baseObj == (Tcl_Obj*) NULL) {
-	      Tcl_Panic ("Out of memory in RcSeekWide");
-	  }
-
-	  RcInvokeTclMethod (rcPtr, "seek", offObj, baseObj,
-			     &res, &resObj, DO_CAPTURE);
-
-	  if (res != TCL_OK) {
-	      RcForwardSetObjError (paramPtr, resObj);
-	      p->offset = -1;
-	  } else {
-	      /* Process a regular result. If the type is wrong this
-	       * may change into an error.
-	       */
-
-	      Tcl_WideInt newLoc;
-	      res = Tcl_GetWideIntFromObj (interp, resObj, &newLoc);
-
-	      if (res == TCL_OK) {
-		  if (newLoc < Tcl_LongAsWide (0)) {
-		      RcForwardSetStaticError (paramPtr, msg_seek_beforestart);
-		      p->offset = -1;
-		  } else {
-		      p->offset = newLoc;
-		  }
-	      } else {
-		  RcForwardSetObjError (paramPtr, RcErrorMarshall (interp));
-		  p->offset = -1;
-	      }
-	  }
-      }
-      break;
-
-    case RcOpWatch:
-      {
-	  RcForwardParamWatch* p = (RcForwardParamWatch*) paramPtr;
-
-	  Tcl_Obj* maskObj = RcDecodeEventMask (p->mask);
-	  RcInvokeTclMethod (rcPtr, "watch", maskObj, NULL,
-			     NULL, NULL, NO_CAPTURE);
-	  Tcl_DecrRefCount (maskObj);
-      }
-    break;
-
-    case RcOpBlock:
-      {
-	  RcForwardParamBlock* p = (RcForwardParamBlock*) evPtr->param;
-	  Tcl_Obj*      blockObj = Tcl_NewBooleanObj(!p->nonblocking);
-
-	  if (blockObj == (Tcl_Obj*) NULL) {
-	      Tcl_Panic ("Out of memory in RcBlock");
-	  }
-
-	  RcInvokeTclMethod (rcPtr, "blocking", blockObj, NULL,
-			     &res, &resObj, DO_CAPTURE);
-
-	  if (res != TCL_OK) {
-	      RcForwardSetObjError (paramPtr, resObj);
-	  }
-      }
-      break;
-
-    case RcOpSetOpt:
-      {
-	  RcForwardParamSetOpt* p = (RcForwardParamSetOpt*) paramPtr;
-	  Tcl_Obj* optionObj;
-	  Tcl_Obj* valueObj;
-
-	  optionObj = Tcl_NewStringObj(p->name,-1);
-	  if (optionObj == (Tcl_Obj*) NULL) {
-	      Tcl_Panic ("Out of memory in RcSetOption");
-	  }
-
-	  valueObj = Tcl_NewStringObj(p->value,-1);
-	  if (valueObj == (Tcl_Obj*) NULL) {
-	      Tcl_Panic ("Out of memory in RcSetOption");
-	  }
-
-	  RcInvokeTclMethod (rcPtr, "configure", optionObj, valueObj,
-			     &res, &resObj, DO_CAPTURE);
-
-	  if (res != TCL_OK) {
-	      RcForwardSetObjError (paramPtr, resObj);
-	  }
-      }
-      break;
-
-    case RcOpGetOpt:
-      {
-	  /* Retrieve the value of one option */
-
-	  RcForwardParamGetOpt* p = (RcForwardParamGetOpt*) paramPtr;
-	  Tcl_Obj*           optionObj;
-
-	  optionObj = Tcl_NewStringObj(p->name,-1);
-	  if (optionObj == (Tcl_Obj*) NULL) {
-	      Tcl_Panic ("Out of memory in RcGetOption");
-	  }
-
-	  RcInvokeTclMethod (rcPtr, "cget", optionObj, NULL,
-			     &res, &resObj, DO_CAPTURE);
-
-	  if (res != TCL_OK) {
-	      RcForwardSetObjError (paramPtr, resObj);
-	  } else {
-	      Tcl_DStringAppend (p->value, Tcl_GetString (resObj), -1);
-	  }
-      }
-      break;
-
-    case RcOpGetOptAll:
-      {
-	  /* Retrieve all options. */
-
-	  RcForwardParamGetOpt* p = (RcForwardParamGetOpt*) paramPtr;
-
-	  RcInvokeTclMethod (rcPtr, "cgetall", NULL, NULL,
-			     &res, &resObj, DO_CAPTURE);
-
-	  if (res != TCL_OK) {
-	      RcForwardSetObjError (paramPtr, resObj);
-	  } else {
-	      /* Extract list, validate that it is a list, and
-	       * #elements. See NOTE (4) as well.
-	       */
-
-	      int       listc;
-	      Tcl_Obj** listv;
-
-	      res = Tcl_ListObjGetElements (interp, resObj, &listc, &listv);
-	      if (res != TCL_OK) {
-		  RcForwardSetObjError (paramPtr, RcErrorMarshall (interp));
-
-	      } else if ((listc % 2) == 1) {
-	          /* Odd number of elements is wrong.
-		   * [x].
-		   */
-
-	          char* buf = ckalloc (200);
-		  sprintf (buf,
-			   "{Expected list with even number of elements, got %d %s instead}",
-			   listc,
-			   (listc == 1 ? "element" : "elements"));
-		  
-		  RcForwardSetDynError (paramPtr, buf);
-	      } else {
-		  int len;
-		  char* str = Tcl_GetStringFromObj (resObj, &len);
-
-		  if (len) {
-		      Tcl_DStringAppend (p->value, " ", 1);
-		      Tcl_DStringAppend (p->value, str, len);
-		  }
-	      }
-	  }
-      }
-      break;
+	/*
+	 * The destination thread for the following operations is
+	 * rcPtr->thread, which contains rcPtr->interp, the interp we have to
+	 * call upon for the driver.
+	 */
+
+    case ForwardedClose:
+	/*
+	 * No parameters/results.
+	 */
+
+	if (InvokeTclMethod(rcPtr, "finalize", NULL, NULL, &resObj,
+		0) != TCL_OK) {
+	    ForwardSetObjError(paramPtr, resObj);
+	}
+
+	/*
+	 * Freeing is done here, in the origin thread, because the argv[]
+	 * objects belong to this thread. Deallocating them in a different
+	 * thread is not allowed
+	 */
+
+	FreeReflectedChannel(rcPtr);
+	break;
+
+    case ForwardedInput: {
+	Tcl_Obj *toReadObj = Tcl_NewIntObj(paramPtr->input.toRead);
+
+	if (InvokeTclMethod(rcPtr, "read", toReadObj, NULL, &resObj,
+		0) != TCL_OK) {
+	    ForwardSetObjError(paramPtr, resObj);
+	    paramPtr->input.toRead = -1;
+	} else {
+	    /*
+	     * Process a regular result.
+	     */
+
+	    int bytec;		/* Number of returned bytes */
+	    unsigned char *bytev; /* Array of returned bytes */
+
+	    bytev = Tcl_GetByteArrayFromObj(resObj, &bytec);
+
+	    if (paramPtr->input.toRead < bytec) {
+		ForwardSetStaticError(paramPtr, msg_read_toomuch);
+		paramPtr->input.toRead = -1;
+	    } else {
+		if (bytec > 0) {
+		    memcpy(paramPtr->input.buf, bytev, bytec);
+		}
+		paramPtr->input.toRead = bytec;
+	    }
+	}
+	break;
+    }
+
+    case ForwardedOutput: {
+	Tcl_Obj *bufObj = Tcl_NewByteArrayObj((unsigned char *)
+		paramPtr->output.buf, paramPtr->output.toWrite);
+
+	if (InvokeTclMethod(rcPtr, "write", bufObj, NULL, &resObj,
+		0) != TCL_OK) {
+	    ForwardSetObjError(paramPtr, resObj);
+	    paramPtr->output.toWrite = -1;
+	} else {
+	    /*
+	     * Process a regular result.
+	     */
+
+	    int written;
+
+	    if (Tcl_GetIntFromObj(interp, resObj, &written) != TCL_OK) {
+		ForwardSetObjError(paramPtr, MarshallError(interp));
+		paramPtr->output.toWrite = -1;
+	    } else if (written==0 || paramPtr->output.toWrite<written) {
+		ForwardSetStaticError(paramPtr, msg_write_toomuch);
+		paramPtr->output.toWrite = -1;
+	    } else {
+		paramPtr->output.toWrite = written;
+	    }
+	}
+	break;
+    }
+
+    case ForwardedSeek: {
+	Tcl_Obj *offObj = Tcl_NewWideIntObj(paramPtr->seek.offset);
+	Tcl_Obj *baseObj = Tcl_NewStringObj(
+		(paramPtr->seek.seekMode==SEEK_SET) ? "start" :
+		(paramPtr->seek.seekMode==SEEK_CUR) ? "current" : "end"), -1);
+
+	if (InvokeTclMethod(rcPtr, "seek", offObj, baseObj, &resObj,
+		0) != TCL_OK) {
+	    ForwardSetObjError(paramPtr, resObj);
+	    paramPtr->seek.offset = -1;
+	} else {
+	    /*
+	     * Process a regular result. If the type is wrong this may change
+	     * into an error.
+	     */
+
+	    Tcl_WideInt newLoc;
+
+	    if (Tcl_GetWideIntFromObj(interp, resObj, &newLoc) == TCL_OK) {
+		if (newLoc < Tcl_LongAsWide(0)) {
+		    ForwardSetStaticError(paramPtr, msg_seek_beforestart);
+		    paramPtr->seek.offset = -1;
+		} else {
+		    paramPtr->seek.offset = newLoc;
+		}
+	    } else {
+		ForwardSetObjError(paramPtr, MarshallError(interp));
+		paramPtr->seek.offset = -1;
+	    }
+	}
+	break;
+    }
+
+    case ForwardedWatch: {
+	Tcl_Obj *maskObj = DecodeEventMask(paramPtr->watch.mask);
+
+	(void) InvokeTclMethod(rcPtr, "watch", maskObj, NULL, NULL, NULL,
+		INVOKE_NO_CAPTURE);
+	Tcl_DecrRefCount(maskObj);
+	break;
+    }
+
+    case ForwardedBlock: {
+	Tcl_Obj *blockObj = Tcl_NewBooleanObj(!paramPtr->block.nonblocking);
+
+	if (InvokeTclMethod(rcPtr, "blocking", blockObj, NULL, &resObj,
+		0) != TCL_OK) {
+	    ForwardSetObjError(paramPtr, resObj);
+	}
+	break;
+    }
+
+    case ForwardedSetOpt: {
+	Tcl_Obj *optionObj = Tcl_NewStringObj(paramPtr->setOpt.name, -1);
+	Tcl_Obj *valueObj = Tcl_NewStringObj(paramPtr->setOpt.value, -1);
+
+	if (InvokeTclMethod(rcPtr, "configure", optionObj, valueObj, &resObj,
+		0) != TCL_OK) {
+	    ForwardSetObjError(paramPtr, resObj);
+	}
+	break;
+    }
+
+    case ForwardedGetOpt: {
+	/*
+	 * Retrieve the value of one option.
+	 */
+
+	Tcl_Obj *optionObj = Tcl_NewStringObj(paramPtr->getOpt.name, -1);
+
+	if (InvokeTclMethod(rcPtr, "cget", optionObj, NULL, &resObj,
+		0) != TCL_OK) {
+	    ForwardSetObjError(paramPtr, resObj);
+	} else {
+	    Tcl_DStringAppend(paramPtr->getOpt.value, TclGetString(resObj),-1);
+	}
+	break;
+    }
+
+    case ForwardedGetOptAll:
+	/*
+	 * Retrieve all options.
+	 */
+
+	if (InvokeTclMethod(rcPtr, "cgetall", NULL, NULL, &resObj,
+		0) != TCL_OK) {
+	    ForwardSetObjError(paramPtr, resObj);
+	} else {
+	    /*
+	     * Extract list, validate that it is a list, and #elements. See
+	     * NOTE (4) as well.
+	     */
+
+	    int listc;
+	    Tcl_Obj** listv;
+
+	    if (Tcl_ListObjGetElements(interp, resObj, &listc,
+		    &listv) != TCL_OK) {
+		ForwardSetObjError(paramPtr, MarshallError(interp));
+	    } else if ((listc % 2) == 1) {
+		/*
+		 * Odd number of elements is wrong. [x].
+		 */
+
+		char *buf = ckalloc(200);
+		sprintf(buf,
+			"{Expected list with even number of elements, got %d %s instead}",
+			listc, (listc == 1 ? "element" : "elements"));
+
+		ForwardSetDynamicError(paramPtr, buf);
+	    } else {
+		int len;
+		CONST char *str = Tcl_GetStringFromObj(resObj, &len);
+
+		if (len) {
+		    Tcl_DStringAppend(paramPtr->getOpt.value, " ", 1);
+		    Tcl_DStringAppend(paramPtr->getOpt.value, str, len);
+		}
+	    }
+	}
+	break;
 
     default:
-      /* Bad operation code */
-      Tcl_Panic ("Bad operation code in RcForwardProc");
-      break;
+	/*
+	 * Bad operation code.
+	 */
+	Tcl_Panic("Bad operation code in ForwardProc");
+	break;
     }
 
-    /* Remove the reference we held on the result of the invoke, if we had
-     * such
+    /*
+     * Remove the reference we held on the result of the invoke, if we had
+     * such.
      */
+
     if (resObj != NULL) {
-	Tcl_DecrRefCount (resObj);
+	Tcl_DecrRefCount(resObj);
     }
 
     if (resultPtr) {
-        /*
-	 * Report the forwarding result synchronously to the waiting
-	 * caller. This unblocks (*) as well. This is wrapped into a
-	 * conditional because the caller may have exited in the mean
-	 * time.
+	/*
+	 * Report the forwarding result synchronously to the waiting caller.
+	 * This unblocks (*) as well. This is wrapped into a conditional
+	 * because the caller may have exited in the mean time.
 	 */
 
-        Tcl_MutexLock(&rcForwardMutex);
+	Tcl_MutexLock(&rcForwardMutex);
 	resultPtr->result = TCL_OK;
 	Tcl_ConditionNotify(&resultPtr->done);
 	Tcl_MutexUnlock(&rcForwardMutex);
@@ -2557,97 +2443,92 @@ RcForwardProc (evGPtr, mask)
     return 1;
 }
 
-
 static void
-RcSrcExitProc (clientData)
-     ClientData clientData;
+SrcExitProc(
+    ClientData clientData)
 {
-  RcForwardingEvent*  evPtr = (RcForwardingEvent*) clientData;
-  RcForwardingResult* resultPtr;
-  RcForwardParamBase* paramPtr;
-
-  /* NOTE (2): Can this handler be called with the originator blocked ?
-   * NOTE (2): ---
-   */
+    ForwardingEvent *evPtr = (ForwardingEvent *) clientData;
+    ForwardingResult *resultPtr;
+    ForwardParam *paramPtr;
 
-  /* The originator for the event exited. It is not sure if this
-   * can happen, as the originator should be blocked at (*) while
-   * the event is in transit/pending.
-   */
+    /*
+     * NOTE (2): Can this handler be called with the originator blocked?
+     */
 
-  /*
-   * We make sure that the event cannot refer to the result anymore,
-   * remove it from the list of pending results and free the
-   * structure. Locking the access ensures that we cannot get in
-   * conflict with "RcForwardProc", should it already execute the
-   * event.
-   */
+    /*
+     * The originator for the event exited. It is not sure if this can happen,
+     * as the originator should be blocked at (*) while the event is in
+     * transit/pending.
+     *
+     * We make sure that the event cannot refer to the result anymore, remove
+     * it from the list of pending results and free the structure. Locking the
+     * access ensures that we cannot get in conflict with "ForwardProc",
+     * should it already execute the event.
+     */
 
-  Tcl_MutexLock(&rcForwardMutex);
+    Tcl_MutexLock(&rcForwardMutex);
 
-  resultPtr = evPtr->resultPtr;
-  paramPtr  = (RcForwardParamBase*) evPtr->param;
+    resultPtr = evPtr->resultPtr;
+    paramPtr = evPtr->param;
 
-  evPtr->resultPtr  = NULL;
-  resultPtr->evPtr  = NULL;
-  resultPtr->result = TCL_ERROR;
+    evPtr->resultPtr = NULL;
+    resultPtr->evPtr = NULL;
+    resultPtr->result = TCL_ERROR;
 
-  RcForwardSetStaticError (paramPtr, msg_send_originlost);
+    ForwardSetStaticError(paramPtr, msg_send_originlost);
 
-  /* See below: TclSpliceOut(resultPtr, forwardList); */
+    /*
+     * See below: TclSpliceOut(resultPtr, forwardList);
+     */
 
-  Tcl_MutexUnlock(&rcForwardMutex);
+    Tcl_MutexUnlock(&rcForwardMutex);
 
-  /*
-   * This unlocks (*). The structure will be spliced out and freed by
-   * "RcForwardProc". Maybe.
-   */
+    /*
+     * This unlocks (*). The structure will be spliced out and freed by
+     * "ForwardProc". Maybe.
+     */
 
-  Tcl_ConditionNotify(&resultPtr->done);
+    Tcl_ConditionNotify(&resultPtr->done);
 }
 
-
 static void
-RcDstExitProc (clientData)
-     ClientData clientData;
+DstExitProc(
+    ClientData clientData)
 {
-  RcForwardingEvent*  evPtr     = (RcForwardingEvent*) clientData;
-  RcForwardingResult* resultPtr = evPtr->resultPtr;
-  RcForwardParamBase* paramPtr  = (RcForwardParamBase*) evPtr->param;
+    ForwardingEvent *evPtr = (ForwardingEvent *) clientData;
+    ForwardingResult *resultPtr = evPtr->resultPtr;
+    ForwardParam *paramPtr = evPtr->param;
 
-  /* NOTE (3): It is not clear if the event still exists when this handler is called..
-   * NOTE (3): We might have to use 'resultPtr' as our clientData instead.
-   * NOTE (3): ---
-   */
+    /*
+     * NOTE (3): It is not clear if the event still exists when this handler
+     * is called. We might have to use 'resultPtr' as our clientData instead.
+     */
 
-  /* The receiver for the event exited, before processing the
-   * event. We detach the result now, wake the originator up
-   * and signal failure.
-   */
+    /*
+     * The receiver for the event exited, before processing the event. We
+     * detach the result now, wake the originator up and signal failure.
+     */
 
-  evPtr->resultPtr = NULL;
-  resultPtr->evPtr  = NULL;
-  resultPtr->result = TCL_ERROR;
+    evPtr->resultPtr = NULL;
+    resultPtr->evPtr = NULL;
+    resultPtr->result = TCL_ERROR;
 
-  RcForwardSetStaticError (paramPtr, msg_send_dstlost);
+    ForwardSetStaticError(paramPtr, msg_send_dstlost);
 
-  Tcl_ConditionNotify(&resultPtr->done);
+    Tcl_ConditionNotify(&resultPtr->done);
 }
 
-
 static void
-RcForwardSetObjError (p,obj)
-     RcForwardParamBase* p;
-     Tcl_Obj*            obj;
+ForwardSetObjError(
+    ForwardParam *p,
+    Tcl_Obj *obj)
 {
-    int   len;
-    char* msg;
-
-    msg = Tcl_GetStringFromObj (obj, &len);
+    int len;
+    CONST char *msgStr = Tcl_GetStringFromObj(obj, &len);
 
-    p->code = TCL_ERROR;
-    p->vol  = 1;
-    p->msg  = strcpy(ckalloc (1+len), msg);
+    len++;
+    ForwardSetDynamicError(paramPtr, ckalloc((unsigned) len));
+    memcpy(p->base.msgStr, msgStr, (unsigned) len);
 }
 #endif