Style guide police

1 files changed, 1144 insertions, 1093 deletions

diff --git a/win/tclWinSerial.c b/win/tclWinSerial.c
index 073a517..b3f7f22 100644
--- a/win/tclWinSerial.c
+++ b/win/tclWinSerial.c
@@ -11,7 +11,7 @@
  *
  * Serial functionality implemented by Rolf.Schroedter@dlr.de
  *
- * RCS: @(#) $Id: tclWinSerial.c,v 1.26 2003/05/11 00:30:31 hobbs Exp $
+ * RCS: @(#) $Id: tclWinSerial.c,v 1.27 2003/08/19 10:33:43 dkf Exp $
  */
 
 #include "tclWinInt.h"
@@ -52,13 +52,15 @@ TCL_DECLARE_MUTEX(serialMutex)
 /*
  * Default time to block between checking status on the serial port.
  */
+
 #define SERIAL_DEFAULT_BLOCKTIME    10  /* 10 msec */
 
 /*
  * Define Win32 read/write error masks returned by ClearCommError()
  */
+
 #define SERIAL_READ_ERRORS      ( CE_RXOVER | CE_OVERRUN | CE_RXPARITY \
-                                | CE_FRAME  | CE_BREAK )
+				| CE_FRAME  | CE_BREAK )
 #define SERIAL_WRITE_ERRORS     ( CE_TXFULL | CE_PTO )
 
 /*
@@ -67,62 +69,63 @@ TCL_DECLARE_MUTEX(serialMutex)
 
 typedef struct SerialInfo {
     HANDLE handle;
-    struct SerialInfo *nextPtr; /* Pointer to next registered serial. */
-    Tcl_Channel channel;        /* Pointer to channel structure. */
-    int validMask;              /* OR'ed combination of TCL_READABLE,
-                                 * TCL_WRITABLE, or TCL_EXCEPTION: indicates
-                                 * which operations are valid on the file. */
-    int watchMask;              /* OR'ed combination of TCL_READABLE,
-                                 * TCL_WRITABLE, or TCL_EXCEPTION: indicates
-                                 * which events should be reported. */
-    int flags;                  /* State flags, see above for a list. */
-    int readable;               /* flag that the channel is readable */
-    int writable;               /* flag that the channel is writable */
-    int blockTime;              /* max. blocktime in msec */
-    unsigned int lastEventTime;	/* Time in milliseconds since last readable event */
+    struct SerialInfo *nextPtr;	/* Pointer to next registered serial. */
+    Tcl_Channel channel;	/* Pointer to channel structure. */
+    int validMask;		/* OR'ed combination of TCL_READABLE,
+				 * TCL_WRITABLE, or TCL_EXCEPTION: indicates
+				 * which operations are valid on the file. */
+    int watchMask;		/* OR'ed combination of TCL_READABLE,
+				 * TCL_WRITABLE, or TCL_EXCEPTION: indicates
+				 * which events should be reported. */
+    int flags;			/* State flags, see above for a list. */
+    int readable;		/* flag that the channel is readable */
+    int writable;		/* flag that the channel is writable */
+    int blockTime;		/* max. blocktime in msec */
+    unsigned int lastEventTime;	/* Time in milliseconds since last readable
+				 * event */
 				/* Next readable event only after blockTime */
-    DWORD error;                /* pending error code returned by
-                                 * ClearCommError() */
-    DWORD lastError;            /* last error code, can be fetched with
-                                 * fconfigure chan -lasterror */
-    DWORD sysBufRead;           /* Win32 system buffer size for read ops, 
-                                 * default=4096 */
-    DWORD sysBufWrite;          /* Win32 system buffer size for write ops, 
-                                 * default=4096 */
-
-    Tcl_ThreadId threadId;      /* Thread to which events should be reported.
-                                 * This value is used by the reader/writer
-                                 * threads. */
-    OVERLAPPED osRead;          /* OVERLAPPED structure for read operations */
-    OVERLAPPED osWrite;         /* OVERLAPPED structure for write operations */
-    HANDLE writeThread;         /* Handle to writer thread. */
-    CRITICAL_SECTION csWrite;   /* Writer thread synchronisation */
-    HANDLE evWritable;          /* Manual-reset event to signal when the
-                                 * writer thread has finished waiting for
-                                 * the current buffer to be written. */
-    HANDLE evStartWriter;       /* Auto-reset event used by the main thread to
-                                 * signal when the writer thread should attempt
-                                 * to write to the serial. */
+    DWORD error;		/* pending error code returned by
+				 * ClearCommError() */
+    DWORD lastError;		/* last error code, can be fetched with
+				 * fconfigure chan -lasterror */
+    DWORD sysBufRead;		/* Win32 system buffer size for read ops, 
+				 * default=4096 */
+    DWORD sysBufWrite;		/* Win32 system buffer size for write ops, 
+				 * default=4096 */
+
+    Tcl_ThreadId threadId;	/* Thread to which events should be reported.
+				 * This value is used by the reader/writer
+				 * threads. */
+    OVERLAPPED osRead;		/* OVERLAPPED structure for read operations */
+    OVERLAPPED osWrite;		/* OVERLAPPED structure for write operations */
+    HANDLE writeThread;		/* Handle to writer thread. */
+    CRITICAL_SECTION csWrite;	/* Writer thread synchronisation */
+    HANDLE evWritable;		/* Manual-reset event to signal when the
+				 * writer thread has finished waiting for
+				 * the current buffer to be written. */
+    HANDLE evStartWriter;	/* Auto-reset event used by the main thread to
+				 * signal when the writer thread should attempt
+				 * to write to the serial. */
     HANDLE evStopWriter;	/* Auto-reset event used by the main thread to
-                                 * signal when the writer thread should close.
+				 * signal when the writer thread should close.
+				 */
+    DWORD writeError;		/* An error caused by the last background
+				 * write.  Set to 0 if no error has been
+				 * detected.  This word is shared with the
+				 * writer thread so access must be
+				 * synchronized with the evWritable object.
 				 */
-    DWORD writeError;           /* An error caused by the last background
-                                 * write.  Set to 0 if no error has been
-                                 * detected.  This word is shared with the
-                                 * writer thread so access must be
-                                 * synchronized with the evWritable object.
-                                 */
-    char *writeBuf;             /* Current background output buffer.
-                                 * Access is synchronized with the evWritable
-                                 * object. */
-    int writeBufLen;            /* Size of write buffer.  Access is
-                                 * synchronized with the evWritable
-                                 * object. */
-    int toWrite;                /* Current amount to be written.  Access is
-                                 * synchronized with the evWritable object. */
-    int writeQueue;             /* Number of bytes pending in output queue.
-                                 * Offset to DCB.cbInQue.
-                                 * Used to query [fconfigure -queue] */
+    char *writeBuf;		/* Current background output buffer.
+				 * Access is synchronized with the evWritable
+				 * object. */
+    int writeBufLen;		/* Size of write buffer.  Access is
+				 * synchronized with the evWritable
+				 * object. */
+    int toWrite;		/* Current amount to be written.  Access is
+				 * synchronized with the evWritable object. */
+    int writeQueue;		/* Number of bytes pending in output queue.
+				 * Offset to DCB.cbInQue.
+				 * Used to query [fconfigure -queue] */
 } SerialInfo;
 
 typedef struct ThreadSpecificData {
@@ -142,12 +145,12 @@ static Tcl_ThreadDataKey dataKey;
  */
 
 typedef struct SerialEvent {
-    Tcl_Event header;       /* Information that is standard for
-                             * all events. */
-    SerialInfo *infoPtr;    /* Pointer to serial info structure.  Note
-                             * that we still have to verify that the
-                             * serial exists before dereferencing this
-                             * pointer. */
+    Tcl_Event header;		/* Information that is standard for
+				 * all events. */
+    SerialInfo *infoPtr;	/* Pointer to serial info structure.  Note
+				 * that we still have to verify that the
+				 * serial exists before dereferencing this
+				 * pointer. */
 } SerialEvent;
 
 /*
@@ -155,40 +158,47 @@ typedef struct SerialEvent {
  */
 
 static COMMTIMEOUTS no_timeout = {
-    0,               /* ReadIntervalTimeout */
-    0,               /* ReadTotalTimeoutMultiplier */
-    0,               /* ReadTotalTimeoutConstant */
-    0,               /* WriteTotalTimeoutMultiplier */
-    0,               /* WriteTotalTimeoutConstant */
+    0,			/* ReadIntervalTimeout */
+    0,			/* ReadTotalTimeoutMultiplier */
+    0,			/* ReadTotalTimeoutConstant */
+    0,			/* WriteTotalTimeoutMultiplier */
+    0,			/* WriteTotalTimeoutConstant */
 };
 
 /*
  * Declarations for functions used only in this file.
  */
 
-static int      SerialBlockProc(ClientData instanceData, int mode);
-static void     SerialCheckProc(ClientData clientData, int flags);
-static int      SerialCloseProc(ClientData instanceData,
-                Tcl_Interp *interp);
-static int      SerialEventProc(Tcl_Event *evPtr, int flags);
-static void     SerialExitHandler(ClientData clientData);
-static int      SerialGetHandleProc(ClientData instanceData,
-                int direction, ClientData *handlePtr);
-static ThreadSpecificData *SerialInit(void);
-static int      SerialInputProc(ClientData instanceData, char *buf,
-                int toRead, int *errorCode);
-static int      SerialOutputProc(ClientData instanceData, CONST char *buf,
-                int toWrite, int *errorCode);
-static void     SerialSetupProc(ClientData clientData, int flags);
-static void     SerialWatchProc(ClientData instanceData, int mask);
-static void     ProcExitHandler(ClientData clientData);
-static int       SerialGetOptionProc _ANSI_ARGS_((ClientData instanceData,
-                Tcl_Interp *interp, CONST char *optionName,
-                Tcl_DString *dsPtr));
-static int       SerialSetOptionProc _ANSI_ARGS_((ClientData instanceData,
-                Tcl_Interp *interp, CONST char *optionName,
-                CONST char *value));
-static DWORD WINAPI     SerialWriterThread(LPVOID arg);
+static int			SerialBlockProc(ClientData instanceData,
+				    int mode);
+static void			SerialCheckProc(ClientData clientData,
+				    int flags);
+static int			SerialCloseProc(ClientData instanceData,
+				    Tcl_Interp *interp);
+static int			SerialEventProc(Tcl_Event *evPtr, int flags);
+static void			SerialExitHandler(ClientData clientData);
+static int			SerialGetHandleProc(ClientData instanceData,
+				    int direction, ClientData *handlePtr);
+static ThreadSpecificData *	SerialInit(void);
+static int			SerialInputProc(ClientData instanceData,
+				    char *buf, int toRead, int *errorCode);
+static int			SerialOutputProc(ClientData instanceData,
+				    CONST char *buf, int toWrite,
+				    int *errorCode);
+static void			SerialSetupProc(ClientData clientData,
+				    int flags);
+static void			SerialWatchProc(ClientData instanceData,
+				    int mask);
+static void			ProcExitHandler(ClientData clientData);
+static int			SerialGetOptionProc _ANSI_ARGS_((
+				    ClientData instanceData,
+				    Tcl_Interp *interp, CONST char *optionName,
+				    Tcl_DString *dsPtr));
+static int			SerialSetOptionProc _ANSI_ARGS_((
+				    ClientData instanceData,
+				    Tcl_Interp *interp, CONST char *optionName,
+				    CONST char *value));
+static DWORD WINAPI		SerialWriterThread(LPVOID arg);
 
 /*
  * This structure describes the channel type structure for command serial
@@ -196,34 +206,34 @@ static DWORD WINAPI     SerialWriterThread(LPVOID arg);
  */
 
 static Tcl_ChannelType serialChannelType = {
-    "serial",                   /* Type name. */
-    TCL_CHANNEL_VERSION_2,      /* v2 channel */
-    SerialCloseProc,            /* Close proc. */
-    SerialInputProc,            /* Input proc. */
-    SerialOutputProc,           /* Output proc. */
-    NULL,                       /* Seek proc. */
-    SerialSetOptionProc,        /* Set option proc. */
-    SerialGetOptionProc,        /* Get option proc. */
-    SerialWatchProc,            /* Set up notifier to watch the channel. */
-    SerialGetHandleProc,        /* Get an OS handle from channel. */
-    NULL,                       /* close2proc. */
-    SerialBlockProc,            /* Set blocking or non-blocking mode.*/
-    NULL,                       /* flush proc. */
-    NULL,                       /* handler proc. */
+    "serial",			/* Type name. */
+    TCL_CHANNEL_VERSION_2,	/* v2 channel */
+    SerialCloseProc,		/* Close proc. */
+    SerialInputProc,		/* Input proc. */
+    SerialOutputProc,		/* Output proc. */
+    NULL,			/* Seek proc. */
+    SerialSetOptionProc,	/* Set option proc. */
+    SerialGetOptionProc,	/* Get option proc. */
+    SerialWatchProc,		/* Set up notifier to watch the channel. */
+    SerialGetHandleProc,	/* Get an OS handle from channel. */
+    NULL,			/* close2proc. */
+    SerialBlockProc,		/* Set blocking or non-blocking mode.*/
+    NULL,			/* flush proc. */
+    NULL,			/* handler proc. */
 };
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialInit --
  *
- *  This function initializes the static variables for this file.
+ *	This function initializes the static variables for this file.
  *
  * Results:
- *  None.
+ *	None.
  *
  * Side effects:
- *  Creates a new event source.
+ *	Creates a new event source.
  *
  *----------------------------------------------------------------------
  */
@@ -239,37 +249,37 @@ SerialInit()
      */
 
     if (!initialized) {
-        Tcl_MutexLock(&serialMutex);
-        if (!initialized) {
-            initialized = 1;
-            Tcl_CreateExitHandler(ProcExitHandler, NULL);
-        }
-        Tcl_MutexUnlock(&serialMutex);
+	Tcl_MutexLock(&serialMutex);
+	if (!initialized) {
+	    initialized = 1;
+	    Tcl_CreateExitHandler(ProcExitHandler, NULL);
+	}
+	Tcl_MutexUnlock(&serialMutex);
     }
 
-    tsdPtr = (ThreadSpecificData *)TclThreadDataKeyGet(&dataKey);
+    tsdPtr = (ThreadSpecificData *) TclThreadDataKeyGet(&dataKey);
     if (tsdPtr == NULL) {
-        tsdPtr = TCL_TSD_INIT(&dataKey);
-        tsdPtr->firstSerialPtr = NULL;
-        Tcl_CreateEventSource(SerialSetupProc, SerialCheckProc, NULL);
-        Tcl_CreateThreadExitHandler(SerialExitHandler, NULL);
+	tsdPtr = TCL_TSD_INIT(&dataKey);
+	tsdPtr->firstSerialPtr = NULL;
+	Tcl_CreateEventSource(SerialSetupProc, SerialCheckProc, NULL);
+	Tcl_CreateThreadExitHandler(SerialExitHandler, NULL);
     }
     return tsdPtr;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialExitHandler --
  *
- *  This function is called to cleanup the serial module before
- *  Tcl is unloaded.
+ *	This function is called to cleanup the serial module before
+ *	Tcl is unloaded.
  *
  * Results:
- *  None.
+ *	None.
  *
  * Side effects:
- *  Removes the serial event source.
+ *	Removes the serial event source.
  *
  *----------------------------------------------------------------------
  */
@@ -287,28 +297,28 @@ SerialExitHandler(
      * because it performs a blocking flush on all open channels.
      * Note that serial write operations may be blocked due to handshake.
      */
-    for (infoPtr = tsdPtr->firstSerialPtr; infoPtr != NULL;
-            infoPtr = infoPtr->nextPtr) {
-        PurgeComm(infoPtr->handle, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR 
-            | PURGE_RXCLEAR);
 
+    for (infoPtr = tsdPtr->firstSerialPtr; infoPtr != NULL;
+	    infoPtr = infoPtr->nextPtr) {
+	PurgeComm(infoPtr->handle,
+		PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);
     }
     Tcl_DeleteEventSource(SerialSetupProc, SerialCheckProc, NULL);
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * ProcExitHandler --
  *
- *  This function is called to cleanup the process list before
- *  Tcl is unloaded.
+ *	This function is called to cleanup the process list before
+ *	Tcl is unloaded.
  *
  * Results:
- *  None.
+ *	None.
  *
  * Side effects:
- *  Resets the process list.
+ *	Resets the process list.
  *
  *----------------------------------------------------------------------
  */
@@ -321,22 +331,25 @@ ProcExitHandler(
     initialized = 0;
     Tcl_MutexUnlock(&serialMutex);
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialBlockTime --
  *
- *  Wrapper to set Tcl's block time in msec
+ *	Wrapper to set Tcl's block time in msec
  *
  * Results:
- *  None.
+ *	None.
+ *
+ * Side effects:
+ *	Updates the maximum blocking time.
  *----------------------------------------------------------------------
  */
 
 static void
 SerialBlockTime(
-    int msec)          /* milli-seconds */
+    int msec)		/* milli-seconds */
 {
     Tcl_Time blockTime;
 
@@ -344,22 +357,24 @@ SerialBlockTime(
     blockTime.usec = (msec % 1000) * 1000;
     Tcl_SetMaxBlockTime(&blockTime);
 }
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialGetMilliseconds --
  *
- *  Get current time in milliseconds,
- *  Don't care about integer overruns
+ *	Get current time in milliseconds,ignoring integer overruns.
  *
  * Results:
- *  None.
+ *	The current time.
+ *
+ * Side effects:
+ *	None.
  *----------------------------------------------------------------------
  */
 
 static unsigned int
-SerialGetMilliseconds(
-    void)
+SerialGetMilliseconds(void)
 {
     Tcl_Time time;
 
@@ -367,6 +382,7 @@ SerialGetMilliseconds(
 
     return (time.sec * 1000 + time.usec / 1000);
 }
+
 /*
  *----------------------------------------------------------------------
  *
@@ -386,8 +402,8 @@ SerialGetMilliseconds(
 
 void
 SerialSetupProc(
-    ClientData data,    /* Not used. */
-    int flags)          /* Event flags as passed to Tcl_DoOneEvent. */
+    ClientData data,	/* Not used. */
+    int flags)		/* Event flags as passed to Tcl_DoOneEvent. */
 {
     SerialInfo *infoPtr;
     int block = 1;
@@ -395,46 +411,45 @@ SerialSetupProc(
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     if (!(flags & TCL_FILE_EVENTS)) {
-        return;
+	return;
     }
 
     /*
      * Look to see if any events handlers installed. If they are, do not block.
      */
 
-    for (infoPtr = tsdPtr->firstSerialPtr; infoPtr != NULL;
-            infoPtr = infoPtr->nextPtr) {
-
-        if (infoPtr->watchMask & TCL_WRITABLE) {
-            if (WaitForSingleObject(infoPtr->evWritable, 0) != WAIT_TIMEOUT) {
-                block = 0;
-                msec = min( msec, infoPtr->blockTime );
-            }
-        }
-        if( infoPtr->watchMask & TCL_READABLE ) {
-            block = 0;
-            msec = min( msec, infoPtr->blockTime );
-        }
+    for (infoPtr=tsdPtr->firstSerialPtr ; infoPtr!=NULL ;
+	    infoPtr=infoPtr->nextPtr) {
+	if (infoPtr->watchMask & TCL_WRITABLE) {
+	    if (WaitForSingleObject(infoPtr->evWritable, 0) != WAIT_TIMEOUT) {
+		block = 0;
+		msec = min(msec, infoPtr->blockTime);
+	    }
+	}
+	if (infoPtr->watchMask & TCL_READABLE) {
+	    block = 0;
+	    msec = min(msec, infoPtr->blockTime);
+	}
     }
 
     if (!block) {
-        SerialBlockTime(msec);
+	SerialBlockTime(msec);
     }
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialCheckProc --
  *
- *  This procedure is called by Tcl_DoOneEvent to check the serial
- *  event source for events.
+ *	This procedure is called by Tcl_DoOneEvent to check the serial
+ *	event source for events.
  *
  * Results:
- *  None.
+ *	None.
  *
  * Side effects:
- *  May queue an event.
+ *	May queue an event.
  *
  *----------------------------------------------------------------------
  */
@@ -442,7 +457,7 @@ SerialSetupProc(
 static void
 SerialCheckProc(
     ClientData data,    /* Not used. */
-    int flags)          /* Event flags as passed to Tcl_DoOneEvent. */
+    int flags)		/* Event flags as passed to Tcl_DoOneEvent. */
 {
     SerialInfo *infoPtr;
     SerialEvent *evPtr;
@@ -452,7 +467,7 @@ SerialCheckProc(
     unsigned int time;
 
     if (!(flags & TCL_FILE_EVENTS)) {
-        return;
+	return;
     }
 
     /*
@@ -460,81 +475,84 @@ SerialCheckProc(
      * queued.
      */
 
-    for (infoPtr = tsdPtr->firstSerialPtr; infoPtr != NULL;
-            infoPtr = infoPtr->nextPtr) {
-        if (infoPtr->flags & SERIAL_PENDING) {
-            continue;
-        }
-
-        needEvent = 0;
-
-        /*
-         * If WRITABLE watch mask is set
-         * look for infoPtr->evWritable object
-         */
-        if (infoPtr->watchMask & TCL_WRITABLE) {
-            if (WaitForSingleObject(infoPtr->evWritable, 0) != WAIT_TIMEOUT) {
-                infoPtr->writable = 1;
-                needEvent = 1;
-            }
-        }
-        
-        /*
-         * If READABLE watch mask is set
-         * call ClearCommError to poll cbInQue
-         * Window errors are ignored here
-         */
-
-        if( infoPtr->watchMask & TCL_READABLE ) {
-            if( ClearCommError( infoPtr->handle, &infoPtr->error, &cStat ) ) {
-                /*
-                 * Look for characters already pending in windows queue.
-                 * If they are, poll.
-                 */
-
-                if( infoPtr->watchMask & TCL_READABLE ) {
-                    /*
-                     * force fileevent after serial read error
-                     */
-                    if( (cStat.cbInQue > 0) ||
-                            (infoPtr->error & SERIAL_READ_ERRORS) ) {
-                        infoPtr->readable = 1;
+    for (infoPtr=tsdPtr->firstSerialPtr ; infoPtr!=NULL ;
+	    infoPtr=infoPtr->nextPtr) {
+	if (infoPtr->flags & SERIAL_PENDING) {
+	    continue;
+	}
+
+	needEvent = 0;
+
+	/*
+	 * If WRITABLE watch mask is set look for infoPtr->evWritable
+	 * object
+	 */
+
+	if (infoPtr->watchMask & TCL_WRITABLE) {
+	    if (WaitForSingleObject(infoPtr->evWritable, 0) != WAIT_TIMEOUT) {
+		infoPtr->writable = 1;
+		needEvent = 1;
+	    }
+	}
+
+	/*
+	 * If READABLE watch mask is set call ClearCommError to poll
+	 * cbInQue Window errors are ignored here
+	 */
+
+	if (infoPtr->watchMask & TCL_READABLE) {
+	    if (ClearCommError(infoPtr->handle, &infoPtr->error, &cStat)) {
+		/*
+		 * Look for characters already pending in windows
+		 * queue.  If they are, poll.
+		 */
+
+		if (infoPtr->watchMask & TCL_READABLE) {
+		    /*
+		     * force fileevent after serial read error
+		     */
+
+		    if ((cStat.cbInQue > 0) ||
+			    (infoPtr->error & SERIAL_READ_ERRORS)) {
+			infoPtr->readable = 1;
 			time = SerialGetMilliseconds();
 			if ((unsigned int) (time - infoPtr->lastEventTime)
 				>= (unsigned int) infoPtr->blockTime) {
 			    needEvent = 1;
 			    infoPtr->lastEventTime = time;
 			}
-                    }
-                }
-            }
-        }
-
-        /*
-         * Queue an event if the serial is signaled for reading or writing.
-         */
-        if (needEvent) {
-            infoPtr->flags |= SERIAL_PENDING;
-            evPtr = (SerialEvent *) ckalloc(sizeof(SerialEvent));
-            evPtr->header.proc = SerialEventProc;
-            evPtr->infoPtr = infoPtr;
-            Tcl_QueueEvent((Tcl_Event *) evPtr, TCL_QUEUE_TAIL);
-        }
+		    }
+		}
+	    }
+	}
+
+	/*
+	 * Queue an event if the serial is signaled for reading or
+	 * writing.
+	 */
+
+	if (needEvent) {
+	    infoPtr->flags |= SERIAL_PENDING;
+	    evPtr = (SerialEvent *) ckalloc(sizeof(SerialEvent));
+	    evPtr->header.proc = SerialEventProc;
+	    evPtr->infoPtr = infoPtr;
+	    Tcl_QueueEvent((Tcl_Event *) evPtr, TCL_QUEUE_TAIL);
+	}
     }
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialBlockProc --
  *
- *  Set blocking or non-blocking mode on channel.
+ *	Set blocking or non-blocking mode on channel.
  *
  * Results:
- *  0 if successful, errno when failed.
+ *	0 if successful, errno when failed.
  *
  * Side effects:
- *  Sets the device into blocking or non-blocking mode.
+ *	Sets the device into blocking or non-blocking mode.
  *
  *----------------------------------------------------------------------
  */
@@ -542,39 +560,38 @@ SerialCheckProc(
 static int
 SerialBlockProc(
     ClientData instanceData,    /* Instance data for channel. */
-    int mode)                   /* TCL_MODE_BLOCKING or
-                                 * TCL_MODE_NONBLOCKING. */
+    int mode)			/* TCL_MODE_BLOCKING or
+				 * TCL_MODE_NONBLOCKING. */
 {
     int errorCode = 0;
-
     SerialInfo *infoPtr = (SerialInfo *) instanceData;
 
     /*
      * Only serial READ can be switched between blocking & nonblocking
-     * using COMMTIMEOUTS.
-     * Serial write emulates blocking & nonblocking by the SerialWriterThread.
+     * using COMMTIMEOUTS.  Serial write emulates blocking &
+     * nonblocking by the SerialWriterThread.
      */
 
     if (mode == TCL_MODE_NONBLOCKING) {
-        infoPtr->flags |= SERIAL_ASYNC;
+	infoPtr->flags |= SERIAL_ASYNC;
     } else {
-        infoPtr->flags &= ~(SERIAL_ASYNC);
+	infoPtr->flags &= ~(SERIAL_ASYNC);
     }
     return errorCode;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialCloseProc --
  *
- *  Closes a serial based IO channel.
+ *	Closes a serial based IO channel.
  *
  * Results:
- *  0 on success, errno otherwise.
+ *	0 on success, errno otherwise.
  *
  * Side effects:
- *  Closes the physical channel.
+ *	Closes the physical channel.
  *
  *----------------------------------------------------------------------
  */
@@ -582,7 +599,7 @@ SerialBlockProc(
 static int
 SerialCloseProc(
     ClientData instanceData,    /* Pointer to SerialInfo structure. */
-    Tcl_Interp *interp)         /* For error reporting. */
+    Tcl_Interp *interp)		/* For error reporting. */
 {
     SerialInfo *serialPtr = (SerialInfo *) instanceData;
     int errorCode, result = 0;
@@ -593,18 +610,18 @@ SerialCloseProc(
     errorCode = 0;
 
     if (serialPtr->validMask & TCL_READABLE) {
-        PurgeComm(serialPtr->handle, PURGE_RXABORT | PURGE_RXCLEAR);
-        CloseHandle(serialPtr->osRead.hEvent);
+	PurgeComm(serialPtr->handle, PURGE_RXABORT | PURGE_RXCLEAR);
+	CloseHandle(serialPtr->osRead.hEvent);
     }
     serialPtr->validMask &= ~TCL_READABLE;
- 
+
     if (serialPtr->validMask & TCL_WRITABLE) {
 
-        /*
-         * Generally we cannot wait for a pending write operation
-         * because it may hang due to handshake
-         *    WaitForSingleObject(serialPtr->evWritable, INFINITE);
-         */
+	/*
+	 * Generally we cannot wait for a pending write operation
+	 * because it may hang due to handshake
+	 *    WaitForSingleObject(serialPtr->evWritable, INFINITE);
+	 */
 
 	/*
 	 * The thread may have already closed on it's own.  Check it's
@@ -646,32 +663,32 @@ SerialCloseProc(
 	    }
 	}
 
-        CloseHandle(serialPtr->writeThread);
+	CloseHandle(serialPtr->writeThread);
 	CloseHandle(serialPtr->osWrite.hEvent);
 	DeleteCriticalSection(&serialPtr->csWrite);
-        CloseHandle(serialPtr->evWritable);
-        CloseHandle(serialPtr->evStartWriter);
-        CloseHandle(serialPtr->evStopWriter);
-        serialPtr->writeThread = NULL;
+	CloseHandle(serialPtr->evWritable);
+	CloseHandle(serialPtr->evStartWriter);
+	CloseHandle(serialPtr->evStopWriter);
+	serialPtr->writeThread = NULL;
 
-        PurgeComm(serialPtr->handle, PURGE_TXABORT | PURGE_TXCLEAR);
+	PurgeComm(serialPtr->handle, PURGE_TXABORT | PURGE_TXCLEAR);
     }
     serialPtr->validMask &= ~TCL_WRITABLE;
 
     /*
-     * Don't close the Win32 handle if the handle is a standard channel
-     * during the thread exit process.  Otherwise, one thread may kill
-     * the stdio of another.
+     * Don't close the Win32 handle if the handle is a standard
+     * channel during the thread exit process.  Otherwise, one thread
+     * may kill the stdio of another.
      */
 
     if (!TclInThreadExit()
-	|| ((GetStdHandle(STD_INPUT_HANDLE) != serialPtr->handle)
-	&& (GetStdHandle(STD_OUTPUT_HANDLE) != serialPtr->handle)
-	&& (GetStdHandle(STD_ERROR_HANDLE) != serialPtr->handle))) {
-	    if (CloseHandle(serialPtr->handle) == FALSE) {
-		TclWinConvertError(GetLastError());
-		errorCode = errno;
-	    }
+	    || ((GetStdHandle(STD_INPUT_HANDLE) != serialPtr->handle)
+	    && (GetStdHandle(STD_OUTPUT_HANDLE) != serialPtr->handle)
+	    && (GetStdHandle(STD_ERROR_HANDLE) != serialPtr->handle))) {
+	if (CloseHandle(serialPtr->handle) == FALSE) {
+	    TclWinConvertError(GetLastError());
+	    errorCode = errno;
+	}
     }
 
     serialPtr->watchMask &= serialPtr->validMask;
@@ -680,55 +697,57 @@ SerialCloseProc(
      * Remove the file from the list of watched files.
      */
 
-    for (nextPtrPtr = &(tsdPtr->firstSerialPtr), infoPtr = *nextPtrPtr;
-	    infoPtr != NULL;
-	    nextPtrPtr = &infoPtr->nextPtr, infoPtr = *nextPtrPtr) {
-        if (infoPtr == (SerialInfo *)serialPtr) {
-            *nextPtrPtr = infoPtr->nextPtr;
-            break;
-        }
+    for (nextPtrPtr=&(tsdPtr->firstSerialPtr), infoPtr=*nextPtrPtr;
+	    infoPtr!=NULL;
+	    nextPtrPtr=&infoPtr->nextPtr, infoPtr=*nextPtrPtr) {
+	if (infoPtr == (SerialInfo *)serialPtr) {
+	    *nextPtrPtr = infoPtr->nextPtr;
+	    break;
+	}
     }
 
     /*
      * Wrap the error file into a channel and give it to the cleanup
      * routine.
      */
+
     if (serialPtr->writeBuf != NULL) {
-        ckfree(serialPtr->writeBuf);
-        serialPtr->writeBuf = NULL;
+	ckfree(serialPtr->writeBuf);
+	serialPtr->writeBuf = NULL;
     }
     ckfree((char*) serialPtr);
 
     if (errorCode == 0) {
-        return result;
+	return result;
     }
     return errorCode;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * blockingRead --
  *
- *  Perform a blocking read into the buffer given. Returns
- *  count of how many bytes were actually read, and an error indication.
+ *	Perform a blocking read into the buffer given. Returns count
+ *	of how many bytes were actually read, and an error indication.
  *
  * Results:
- *  A count of how many bytes were read is returned and an error
- *  indication is returned.
+ *	A count of how many bytes were read is returned and an error
+ *	indication is returned.
  *
  * Side effects:
- *  Reads input from the actual channel.
+ *	Reads input from the actual channel.
  *
  *----------------------------------------------------------------------
  */
+
 static int
 blockingRead( 
-    SerialInfo *infoPtr,    /* Serial info structure */
-    LPVOID buf,             /* The input buffer pointer */
-    DWORD  bufSize,         /* The number of bytes to read */
-    LPDWORD  lpRead,        /* Returns number of bytes read */ 
-    LPOVERLAPPED osPtr )    /* OVERLAPPED structure */
+    SerialInfo *infoPtr,	/* Serial info structure */
+    LPVOID buf,			/* The input buffer pointer */
+    DWORD  bufSize,		/* The number of bytes to read */
+    LPDWORD  lpRead,		/* Returns number of bytes read */ 
+    LPOVERLAPPED osPtr )	/* OVERLAPPED structure */
 {
     /*
      *  Perform overlapped blocking read. 
@@ -740,88 +759,94 @@ blockingRead(
     /* 
      * Set Offset to ZERO, otherwise NT4.0 may report an error.
      */
+
     osPtr->Offset = osPtr->OffsetHigh = 0;
     ResetEvent(osPtr->hEvent);
-    if (! ReadFile(infoPtr->handle, buf, bufSize, lpRead, osPtr) ) {
-        if (GetLastError() != ERROR_IO_PENDING) {
-            /* ReadFile failed, but it isn't delayed. Report error. */
-            return FALSE;
-        } else {   
-            /* Read is pending, wait for completion, timeout ? */
-            if (! GetOverlappedResult(infoPtr->handle, osPtr, lpRead, TRUE) ) {
-                return FALSE;
-            }
-        }
+    if (!ReadFile(infoPtr->handle, buf, bufSize, lpRead, osPtr)) {
+	if (GetLastError() != ERROR_IO_PENDING) {
+	    /* ReadFile failed, but it isn't delayed. Report error. */
+	    return FALSE;
+	} else {   
+	    /* Read is pending, wait for completion, timeout ? */
+	    if (!GetOverlappedResult(infoPtr->handle, osPtr, lpRead, TRUE)) {
+		return FALSE;
+	    }
+	}
     } else {
-        /* ReadFile completed immediately. */
+	/* ReadFile completed immediately. */
     }
     return TRUE;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * blockingWrite --
  *
- *  Perform a blocking write from the buffer given. Returns
- *  count of how many bytes were actually written, and an error indication.
+ *	Perform a blocking write  from the buffer given. Returns count
+ *	of  how  many  bytes  were  actually  written,  and  an  error
+ *	indication.
  *
  * Results:
- *  A count of how many bytes were written is returned and an error
- *  indication is returned.
+ *	A count of how many bytes were written is returned and an error
+ *	indication is returned.
  *
  * Side effects:
- *  Writes output to the actual channel.
+ *	Writes output to the actual channel.
  *
  *----------------------------------------------------------------------
  */
+
 static int
 blockingWrite(
-    SerialInfo *infoPtr,    /* Serial info structure */
-    LPVOID  buf,            /* The output buffer pointer */
-    DWORD   bufSize,        /* The number of bytes to write */
-    LPDWORD lpWritten,      /* Returns number of bytes written */ 
-    LPOVERLAPPED osPtr )    /* OVERLAPPED structure */
+    SerialInfo *infoPtr,	/* Serial info structure */
+    LPVOID  buf,		/* The output buffer pointer */
+    DWORD   bufSize,		/* The number of bytes to write */
+    LPDWORD lpWritten,		/* Returns number of bytes written */ 
+    LPOVERLAPPED osPtr )	/* OVERLAPPED structure */
 {
     int result;
+
     /*
-    *  Perform overlapped blocking write. 
-    *  1. Reset the overlapped event
-    *  2. Remove these bytes from the output queue counter
-    *  3. Start overlapped write operation
-    *  3. Remove these bytes from the output queue counter
-    *  4. Wait for completion
-    *  5. Adjust the output queue counter
-    */
+     * Perform overlapped blocking write. 
+     *  1. Reset the overlapped event
+     *  2. Remove these bytes from the output queue counter
+     *  3. Start overlapped write operation
+     *  3. Remove these bytes from the output queue counter
+     *  4. Wait for completion
+     *  5. Adjust the output queue counter
+     */
+
     ResetEvent(osPtr->hEvent);
 
     EnterCriticalSection(&infoPtr->csWrite);
     infoPtr->writeQueue -= bufSize;
-	/* 
-	* Set Offset to ZERO, otherwise NT4.0 may report an error 
-	*/
-	osPtr->Offset = osPtr->OffsetHigh = 0;
+    /* 
+     * Set Offset to ZERO, otherwise NT4.0 may report an error 
+     */
+    osPtr->Offset = osPtr->OffsetHigh = 0;
     result = WriteFile(infoPtr->handle, buf, bufSize, lpWritten, osPtr);
     LeaveCriticalSection(&infoPtr->csWrite);
 
-    if (result == FALSE ) {
-        int err = GetLastError();
-        switch (err) {
-        case ERROR_IO_PENDING:
-            /* Write is pending, wait for completion */
-            if (! GetOverlappedResult(infoPtr->handle, osPtr, lpWritten, TRUE) ) {
-                return FALSE;
-            }
-            break;
-        case ERROR_COUNTER_TIMEOUT:
-            /* Write timeout handled in SerialOutputProc */
-            break;
-        default:
-            /* WriteFile failed, but it isn't delayed. Report error */
-            return FALSE;
-        }
+    if (result == FALSE) {
+	int err = GetLastError();
+	switch (err) {
+	case ERROR_IO_PENDING:
+	    /* Write is pending, wait for completion */
+	    if (!GetOverlappedResult(infoPtr->handle, osPtr, lpWritten,
+		    TRUE)) {
+		return FALSE;
+	    }
+	    break;
+	case ERROR_COUNTER_TIMEOUT:
+	    /* Write timeout handled in SerialOutputProc */
+	    break;
+	default:
+	    /* WriteFile failed, but it isn't delayed. Report error */
+	    return FALSE;
+	}
     } else {
-        /* WriteFile completed immediately. */
+	/* WriteFile completed immediately. */
     }
 
     EnterCriticalSection(&infoPtr->csWrite);
@@ -830,31 +855,33 @@ blockingWrite(
 
     return TRUE;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialInputProc --
  *
- *  Reads input from the IO channel into the buffer given. Returns
- *  count of how many bytes were actually read, and an error indication.
+ *	Reads input from the IO channel into the buffer given. Returns
+ *	count of how many bytes were actually read, and an error
+ *	indication.
  *
  * Results:
- *  A count of how many bytes were read is returned and an error
- *  indication is returned in an output argument.
+ *	A count of how many bytes were read is returned and an error
+ *	indication is returned in an output argument.
  *
  * Side effects:
- *  Reads input from the actual channel.
+ *	Reads input from the actual channel.
  *
  *----------------------------------------------------------------------
  */
+
 static int
 SerialInputProc(
-    ClientData instanceData,    /* Serial state. */
-    char *buf,                  /* Where to store data read. */
-    int bufSize,                /* How much space is available
-                                 * in the buffer? */
-    int *errorCode)             /* Where to store error code. */
+    ClientData instanceData,	/* Serial state. */
+    char *buf,			/* Where to store data read. */
+    int bufSize,		/* How much space is available
+				 * in the buffer? */
+    int *errorCode)		/* Where to store error code. */
 {
     SerialInfo *infoPtr = (SerialInfo *) instanceData;
     DWORD bytesRead = 0;
@@ -865,8 +892,9 @@ SerialInputProc(
     /*
      * Check if there is a CommError pending from SerialCheckProc
      */
-    if( infoPtr->error & SERIAL_READ_ERRORS ){
-        goto commError;
+
+    if (infoPtr->error & SERIAL_READ_ERRORS) {
+	goto commError;
     }
 
     /*
@@ -874,95 +902,96 @@ SerialInputProc(
      * This is the mainly restored good old code from Tcl8.0
      */
 
-    if( ClearCommError( infoPtr->handle, &infoPtr->error, &cStat ) ) {
-        /*
-         * Check for errors here, but not in the evSetup/Check procedures
-         */
-
-        if( infoPtr->error & SERIAL_READ_ERRORS ) {
-            goto commError;
-        }
-        if( infoPtr->flags & SERIAL_ASYNC ) {
-            /*
-             * NON_BLOCKING mode:
-             * Avoid blocking by reading more bytes than available
-             * in input buffer
-             */
-
-            if( cStat.cbInQue > 0 ) {
-                if( (DWORD) bufSize > cStat.cbInQue ) {
-                    bufSize = cStat.cbInQue;
-                }
-            } else {
-                errno = *errorCode = EAGAIN;
-                return -1;
-            }
-        } else {
-            /*
-             * BLOCKING mode:
-             * Tcl trys to read a full buffer of 4 kBytes here
-             */
-
-            if( cStat.cbInQue > 0 ) {
-                if( (DWORD) bufSize > cStat.cbInQue ) {
-                    bufSize = cStat.cbInQue;
-                }
-            } else {
-                bufSize = 1;
-            }
-        }
-    }
-
-    if( bufSize == 0 ) {
-        return bytesRead = 0;
+    if (ClearCommError(infoPtr->handle, &infoPtr->error, &cStat)) {
+	/*
+	 * Check for errors here, but not in the evSetup/Check procedures
+	 */
+
+	if (infoPtr->error & SERIAL_READ_ERRORS) {
+	    goto commError;
+	}
+	if (infoPtr->flags & SERIAL_ASYNC) {
+	    /*
+	     * NON_BLOCKING mode:
+	     * Avoid blocking by reading more bytes than available
+	     * in input buffer
+	     */
+
+	    if (cStat.cbInQue > 0) {
+		if ((DWORD) bufSize > cStat.cbInQue) {
+		    bufSize = cStat.cbInQue;
+		}
+	    } else {
+		errno = *errorCode = EAGAIN;
+		return -1;
+	    }
+	} else {
+	    /*
+	     * BLOCKING mode:
+	     * Tcl trys to read a full buffer of 4 kBytes here
+	     */
+
+	    if (cStat.cbInQue > 0) {
+		if ((DWORD) bufSize > cStat.cbInQue) {
+		    bufSize = cStat.cbInQue;
+		}
+	    } else {
+		bufSize = 1;
+	    }
+	}
+    }
+
+    if (bufSize == 0) {
+	return bytesRead = 0;
     }
 
     /*
-    *  Perform blocking read. Doesn't block in non-blocking mode, 
-    *  because we checked the number of available bytes.
-    */
+     * Perform blocking read. Doesn't block in non-blocking mode, 
+     * because we checked the number of available bytes.
+     */
     if (blockingRead(infoPtr, (LPVOID) buf, (DWORD) bufSize, &bytesRead,
-            &infoPtr->osRead) == FALSE) {
-        goto error;
+	    &infoPtr->osRead) == FALSE) {
+	goto error;
     }
     return bytesRead;
 
-error:
+  error:
     TclWinConvertError(GetLastError());
     *errorCode = errno;
     return -1;
 
-commError:
-    infoPtr->lastError = infoPtr->error;  /* save last error code */
-    infoPtr->error = 0;                   /* reset error code */
-    *errorCode = EIO;                     /* to return read-error only once */
+  commError:
+    infoPtr->lastError = infoPtr->error;/* save last error code */
+    infoPtr->error = 0;			/* reset error code */
+    *errorCode = EIO;			/* to return read-error only once */
     return -1;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialOutputProc --
  *
- *  Writes the given output on the IO channel. Returns count of how
- *  many characters were actually written, and an error indication.
+ *	Writes the given output on the IO channel. Returns count of
+ *	how many characters were actually written, and an error
+ *	indication.
  *
  * Results:
- *  A count of how many characters were written is returned and an
- *  error indication is returned in an output argument.
+ *	A count of how many characters were written is returned and an
+ *	error indication is returned in an output argument.
  *
  * Side effects:
- *  Writes output on the actual channel.
+ *	Writes output on the actual channel.
  *
  *----------------------------------------------------------------------
  */
 
 static int
 SerialOutputProc(
-    ClientData instanceData,    /* Serial state. */
-    CONST char *buf,            /* The data buffer. */
-    int toWrite,                /* How many bytes to write? */
-    int *errorCode)             /* Where to store error code. */
+    ClientData instanceData,	/* Serial state. */
+    CONST char *buf,		/* The data buffer. */
+    int toWrite,		/* How many bytes to write? */
+    int *errorCode)		/* Where to store error code. */
 {
     SerialInfo *infoPtr = (SerialInfo *) instanceData;
     DWORD bytesWritten, timeout;
@@ -974,132 +1003,139 @@ SerialOutputProc(
      * We avoid blocking output after ExitProc or CloseHandler(chan)
      * has been called by checking the corrresponding variables.
      */
-    if( ! initialized || TclInExit() ) {
-        return toWrite;
+
+    if (!initialized || TclInExit()) {
+	return toWrite;
     }
 
     /*
      * Check if there is a CommError pending from SerialCheckProc
      */
-    if( infoPtr->error & SERIAL_WRITE_ERRORS ){
-        infoPtr->lastError = infoPtr->error;  /* save last error code */
-        infoPtr->error = 0;                   /* reset error code */
-        errno = EIO;            
-        goto error;
+
+    if (infoPtr->error & SERIAL_WRITE_ERRORS) {
+	infoPtr->lastError = infoPtr->error;	/* save last error code */
+	infoPtr->error = 0;			/* reset error code */
+	errno = EIO;
+	goto error;
     }
 
     timeout = (infoPtr->flags & SERIAL_ASYNC) ? 0 : INFINITE;
     if (WaitForSingleObject(infoPtr->evWritable, timeout) == WAIT_TIMEOUT) {
-        /*
-         * The writer thread is blocked waiting for a write to complete
-         * and the channel is in non-blocking mode.
-         */
+	/*
+	 * The writer thread is blocked waiting for a write to complete
+	 * and the channel is in non-blocking mode.
+	 */
 
-        errno = EWOULDBLOCK;
-        goto error1;
+	errno = EWOULDBLOCK;
+	goto error1;
     }
+
     /*
      * Check for a background error on the last write.
      */
 
     if (infoPtr->writeError) {
-        TclWinConvertError(infoPtr->writeError);
-        infoPtr->writeError = 0;
-        goto error1;
+	TclWinConvertError(infoPtr->writeError);
+	infoPtr->writeError = 0;
+	goto error1;
     }
 
     /*
      * Remember the number of bytes in output queue
      */
+
     EnterCriticalSection(&infoPtr->csWrite);
     infoPtr->writeQueue += toWrite;
     LeaveCriticalSection(&infoPtr->csWrite);
 
     if (infoPtr->flags & SERIAL_ASYNC) {
-        /*
-         * The serial is non-blocking, so copy the data into the output
-         * buffer and restart the writer thread.
-         */
-
-        if (toWrite > infoPtr->writeBufLen) {
-            /*
-             * Reallocate the buffer to be large enough to hold the data.
-             */
-
-            if (infoPtr->writeBuf) {
-                ckfree(infoPtr->writeBuf);
-            }
-            infoPtr->writeBufLen = toWrite;
-            infoPtr->writeBuf = ckalloc((unsigned int) toWrite);
-        }
-        memcpy(infoPtr->writeBuf, buf, (size_t) toWrite);
-        infoPtr->toWrite = toWrite;
-        ResetEvent(infoPtr->evWritable);
-        SetEvent(infoPtr->evStartWriter);
-        bytesWritten = (DWORD) toWrite;
+	/*
+	 * The serial is non-blocking, so copy the data into the output
+	 * buffer and restart the writer thread.
+	 */
+
+	if (toWrite > infoPtr->writeBufLen) {
+	    /*
+	     * Reallocate the buffer to be large enough to hold the data.
+	     */
+
+	    if (infoPtr->writeBuf) {
+		ckfree(infoPtr->writeBuf);
+	    }
+	    infoPtr->writeBufLen = toWrite;
+	    infoPtr->writeBuf = ckalloc((unsigned int) toWrite);
+	}
+	memcpy(infoPtr->writeBuf, buf, (size_t) toWrite);
+	infoPtr->toWrite = toWrite;
+	ResetEvent(infoPtr->evWritable);
+	SetEvent(infoPtr->evStartWriter);
+	bytesWritten = (DWORD) toWrite;
 
     } else {
-        /*
-        * In the blocking case, just try to write the buffer directly.
-        * This avoids an unnecessary copy.
-        */
-        if (! blockingWrite(infoPtr, (LPVOID) buf, (DWORD) toWrite,
-                &bytesWritten, &infoPtr->osWrite) ) {
-            goto writeError;
-        }
-        if (bytesWritten != (DWORD) toWrite) {
-            /* Write timeout */
-            infoPtr->lastError |= CE_PTO;
-            errno = EIO;
-            goto error;
-        }
+	/*
+	 * In the blocking case, just try to write the buffer directly.
+	 * This avoids an unnecessary copy.
+	 */
+
+	if (!blockingWrite(infoPtr, (LPVOID) buf, (DWORD) toWrite,
+		&bytesWritten, &infoPtr->osWrite)) {
+	    goto writeError;
+	}
+	if (bytesWritten != (DWORD) toWrite) {
+	    /* Write timeout */
+	    infoPtr->lastError |= CE_PTO;
+	    errno = EIO;
+	    goto error;
+	}
     }
 
     return (int) bytesWritten;
 
-writeError:
+  writeError:
     TclWinConvertError(GetLastError());
 
-error:
+  error:
     /* 
      * Reset the output queue counter on error during blocking output 
      */
-/*
-    EnterCriticalSection(&infoPtr->csWrite);
-    infoPtr->writeQueue = 0;
-    LeaveCriticalSection(&infoPtr->csWrite);
-*/
+
+    /*
+     * EnterCriticalSection(&infoPtr->csWrite);
+     * infoPtr->writeQueue = 0;
+     * LeaveCriticalSection(&infoPtr->csWrite);
+     */
   error1: 
     *errorCode = errno;
     return -1;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialEventProc --
  *
- *  This function is invoked by Tcl_ServiceEvent when a file event
- *  reaches the front of the event queue.  This procedure invokes
- *  Tcl_NotifyChannel on the serial.
+ *	This function is invoked by Tcl_ServiceEvent when a file event
+ *	reaches the front of the event queue.  This procedure invokes
+ *	Tcl_NotifyChannel on the serial.
  *
  * Results:
- *  Returns 1 if the event was handled, meaning it should be removed
- *  from the queue.  Returns 0 if the event was not handled, meaning
- *  it should stay on the queue.  The only time the event isn't
- *  handled is if the TCL_FILE_EVENTS flag bit isn't set.
+ *	Returns 1 if the event was handled, meaning it should be
+ *	removed from the queue.  Returns 0 if the event was not
+ *	handled, meaning it should stay on the queue.  The only time
+ *	the event isn't handled is if the TCL_FILE_EVENTS flag bit
+ *	isn't set.
  *
  * Side effects:
- *  Whatever the notifier callback does.
+ *	Whatever the notifier callback does.
  *
  *----------------------------------------------------------------------
  */
 
 static int
 SerialEventProc(
-    Tcl_Event *evPtr,   /* Event to service. */
-    int flags)          /* Flags that indicate what events to
-                         * handle, such as TCL_FILE_EVENTS. */
+    Tcl_Event *evPtr,	/* Event to service. */
+    int flags)		/* Flags that indicate what events to
+			 * handle, such as TCL_FILE_EVENTS. */
 {
     SerialEvent *serialEvPtr = (SerialEvent *)evPtr;
     SerialInfo *infoPtr;
@@ -1107,7 +1143,7 @@ SerialEventProc(
     ThreadSpecificData *tsdPtr = TCL_TSD_INIT(&dataKey);
 
     if (!(flags & TCL_FILE_EVENTS)) {
-        return 0;
+	return 0;
     }
 
     /*
@@ -1118,11 +1154,11 @@ SerialEventProc(
      */
 
     for (infoPtr = tsdPtr->firstSerialPtr; infoPtr != NULL;
-            infoPtr = infoPtr->nextPtr) {
-        if (serialEvPtr->infoPtr == infoPtr) {
-            infoPtr->flags &= ~(SERIAL_PENDING);
-            break;
-        }
+	    infoPtr = infoPtr->nextPtr) {
+	if (serialEvPtr->infoPtr == infoPtr) {
+	    infoPtr->flags &= ~(SERIAL_PENDING);
+	    break;
+	}
     }
 
     /*
@@ -1130,7 +1166,7 @@ SerialEventProc(
      */
 
     if (!infoPtr) {
-        return 1;
+	return 1;
     }
 
     /*
@@ -1140,18 +1176,18 @@ SerialEventProc(
      */
 
     mask = 0;
-    if( infoPtr->watchMask & TCL_WRITABLE ) {
-        if( infoPtr->writable ) {
-            mask |= TCL_WRITABLE;
-            infoPtr->writable = 0;
-        }
+    if (infoPtr->watchMask & TCL_WRITABLE) {
+	if (infoPtr->writable) {
+	    mask |= TCL_WRITABLE;
+	    infoPtr->writable = 0;
+	}
     }
 
-    if( infoPtr->watchMask & TCL_READABLE ) {
-        if( infoPtr->readable ) {
-            mask |= TCL_READABLE;
-            infoPtr->readable = 0;
-        }
+    if (infoPtr->watchMask & TCL_READABLE) {
+	if (infoPtr->readable) {
+	    mask |= TCL_READABLE;
+	    infoPtr->readable = 0;
+	}
     }
 
     /*
@@ -1161,30 +1197,30 @@ SerialEventProc(
     Tcl_NotifyChannel(infoPtr->channel, infoPtr->watchMask & mask);
     return 1;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialWatchProc --
  *
- *  Called by the notifier to set up to watch for events on this
- *  channel.
+ *	Called by the notifier to set up to watch for events on this
+ *	channel.
  *
  * Results:
- *  None.
+ *	None.
  *
  * Side effects:
- *  None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 static void
 SerialWatchProc(
-    ClientData instanceData,     /* Serial state. */
-    int mask)                    /* What events to watch for, OR-ed
-                                  * combination of TCL_READABLE,
-                                  * TCL_WRITABLE and TCL_EXCEPTION. */
+    ClientData instanceData,	/* Serial state. */
+    int mask)			/* What events to watch for, OR-ed
+				 * combination of TCL_READABLE,
+				 * TCL_WRITABLE and TCL_EXCEPTION. */
 {
     SerialInfo **nextPtrPtr, *ptr;
     SerialInfo *infoPtr = (SerialInfo *) instanceData;
@@ -1198,59 +1234,57 @@ SerialWatchProc(
 
     infoPtr->watchMask = mask & infoPtr->validMask;
     if (infoPtr->watchMask) {
-        if (!oldMask) {
-            infoPtr->nextPtr = tsdPtr->firstSerialPtr;
-            tsdPtr->firstSerialPtr = infoPtr;
-        }
-        SerialBlockTime(infoPtr->blockTime);
-    } else {
-        if (oldMask) {
-            /*
-             * Remove the serial port from the list of watched serial ports.
-             */
-
-            for (nextPtrPtr = &(tsdPtr->firstSerialPtr), ptr = *nextPtrPtr;
-                    ptr != NULL;
-                    nextPtrPtr = &ptr->nextPtr, ptr = *nextPtrPtr) {
-                if (infoPtr == ptr) {
-                    *nextPtrPtr = ptr->nextPtr;
-                    break;
-                }
-            }
-        }
+	if (!oldMask) {
+	    infoPtr->nextPtr = tsdPtr->firstSerialPtr;
+	    tsdPtr->firstSerialPtr = infoPtr;
+	}
+	SerialBlockTime(infoPtr->blockTime);
+    } else if (oldMask) {
+	/*
+	 * Remove the serial port from the list of watched serial ports.
+	 */
+
+	for (nextPtrPtr=&(tsdPtr->firstSerialPtr), ptr=*nextPtrPtr;
+		ptr!=NULL;
+		nextPtrPtr=&ptr->nextPtr, ptr=*nextPtrPtr) {
+	    if (infoPtr == ptr) {
+		*nextPtrPtr = ptr->nextPtr;
+		break;
+	    }
+	}
     }
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialGetHandleProc --
  *
- *  Called from Tcl_GetChannelHandle to retrieve OS handles from
- *  inside a command serial port based channel.
+ *	Called from Tcl_GetChannelHandle to retrieve OS handles from
+ *	inside a command serial port based channel.
  *
  * Results:
- *  Returns TCL_OK with the fd in handlePtr, or TCL_ERROR if
- *  there is no handle for the specified direction.
+ *	Returns TCL_OK with the fd in handlePtr, or TCL_ERROR if
+ *	there is no handle for the specified direction.
  *
  * Side effects:
- *  None.
+ *	None.
  *
  *----------------------------------------------------------------------
  */
 
 static int
 SerialGetHandleProc(
-    ClientData instanceData,    /* The serial state. */
-    int direction,              /* TCL_READABLE or TCL_WRITABLE */
-    ClientData *handlePtr)      /* Where to store the handle.  */
+    ClientData instanceData,	/* The serial state. */
+    int direction,		/* TCL_READABLE or TCL_WRITABLE */
+    ClientData *handlePtr)	/* Where to store the handle.  */
 {
     SerialInfo *infoPtr = (SerialInfo *) instanceData;
 
     *handlePtr = (ClientData) infoPtr->handle;
     return TCL_OK;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
@@ -1286,9 +1320,9 @@ SerialWriterThread(LPVOID arg)
     wEvents[1] = infoPtr->evStartWriter;
 
     for (;;) {
-        /*
-         * Wait for the main thread to signal before attempting to write.
-         */
+	/*
+	 * Wait for the main thread to signal before attempting to write.
+	 */
 
 	waitResult = WaitForMultipleObjects(2, wEvents, FALSE, INFINITE);
 
@@ -1301,73 +1335,76 @@ SerialWriterThread(LPVOID arg)
 	    break;
 	}
 
-        buf = infoPtr->writeBuf;
-        toWrite = infoPtr->toWrite;
-
-        myWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-
-        /*
-         * Loop until all of the bytes are written or an error occurs.
-         */
-
-        while (toWrite > 0) {
-            /*
-            *  Check for pending writeError
-            *  Ignore all write operations until the user has been notified
-            */
-            if (infoPtr->writeError) {
-                break;
-            }
-            if (blockingWrite(infoPtr, (LPVOID) buf, (DWORD) toWrite, 
-                    &bytesWritten, &myWrite) == FALSE) {
-                infoPtr->writeError = GetLastError();
-                break;
-            }
-            if (bytesWritten != toWrite) {
-                /* Write timeout */
-                infoPtr->writeError = ERROR_WRITE_FAULT;
-                break;
-            }
-            toWrite -= bytesWritten;
-            buf += bytesWritten;
-        }
-
-        CloseHandle(myWrite.hEvent);
-        /*
-         * Signal the main thread by signalling the evWritable event and
-         * then waking up the notifier thread.
-         */
-        SetEvent(infoPtr->evWritable);
-
-        /*
-         * Alert the foreground thread.  Note that we need to treat this like
-         * a critical section so the foreground thread does not terminate
-         * this thread while we are holding a mutex in the notifier code.
-         */
-
-        Tcl_MutexLock(&serialMutex);
-        Tcl_ThreadAlert(infoPtr->threadId);
-        Tcl_MutexUnlock(&serialMutex);
+	buf = infoPtr->writeBuf;
+	toWrite = infoPtr->toWrite;
+
+	myWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+
+	/*
+	 * Loop until all of the bytes are written or an error occurs.
+	 */
+
+	while (toWrite > 0) {
+	    /*
+	     *  Check for pending writeError.  Ignore all write
+	     *  operations until the user has been notified
+	     */
+
+	    if (infoPtr->writeError) {
+		break;
+	    }
+	    if (blockingWrite(infoPtr, (LPVOID) buf, (DWORD) toWrite, 
+		    &bytesWritten, &myWrite) == FALSE) {
+		infoPtr->writeError = GetLastError();
+		break;
+	    }
+	    if (bytesWritten != toWrite) {
+		/* Write timeout */
+		infoPtr->writeError = ERROR_WRITE_FAULT;
+		break;
+	    }
+	    toWrite -= bytesWritten;
+	    buf += bytesWritten;
+	}
+
+	CloseHandle(myWrite.hEvent);
+
+	/*
+	 * Signal the main thread by signalling the evWritable event
+	 * and then waking up the notifier thread.
+	 */
+
+	SetEvent(infoPtr->evWritable);
+
+	/*
+	 * Alert the foreground thread.  Note that we need to treat
+	 * this like a critical section so the foreground thread does
+	 * not terminate this thread while we are holding a mutex in
+	 * the notifier code.
+	 */
+
+	Tcl_MutexLock(&serialMutex);
+	Tcl_ThreadAlert(infoPtr->threadId);
+	Tcl_MutexUnlock(&serialMutex);
     }
 
     return 0;
 }
-
-
+
 /*
  *----------------------------------------------------------------------
  *
  * TclWinSerialReopen --
  *
- *  Reopens the serial port with the OVERLAPPED FLAG set
+ *	Reopens the serial port with the OVERLAPPED FLAG set
  *
  * Results:
- *  Returns the new handle, or INVALID_HANDLE_VALUE
- *  Normally there shouldn't be any error, 
- *  because the same channel has previously been succeesfully opened.
+ *	Returns the new handle, or INVALID_HANDLE_VALUE.  Normally
+ *	there shouldn't be any error, because the same channel has
+ *	previously been succeesfully opened.
  *
  * Side effects:
- *  May close the original handle
+ *	May close the original handle
  *
  *----------------------------------------------------------------------
  */
@@ -1383,31 +1420,33 @@ TclWinSerialReopen(handle, name, access)
     tsdPtr = SerialInit();
 
     /* 
-    * Multithreaded I/O needs the overlapped flag set
-    * otherwise ClearCommError blocks under Windows NT/2000 until serial
-    * output is finished
-    */
+     * Multithreaded I/O needs the overlapped flag set
+     * otherwise ClearCommError blocks under Windows NT/2000 until serial
+     * output is finished
+     */
+
     if (CloseHandle(handle) == FALSE) {
-        return INVALID_HANDLE_VALUE;
+	return INVALID_HANDLE_VALUE;
     }
-    handle = (*tclWinProcs->createFileProc)(name, access, 
-                0, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
+    handle = (*tclWinProcs->createFileProc)(name, access, 0, 0,
+	    OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
     return handle;
 }
+
 /*
  *----------------------------------------------------------------------
  *
  * TclWinOpenSerialChannel --
  *
- *  Constructs a Serial port channel for the specified standard OS handle.
- *      This is a helper function to break up the construction of
- *      channels into File, Console, or Serial.
+ *	Constructs a Serial port channel for the specified standard OS
+ *	handle.  This is a helper function to break up the
+ *	construction of channels into File, Console, or Serial.
  *
  * Results:
- *  Returns the new channel, or NULL.
+ *	Returns the new channel, or NULL.
  *
  * Side effects:
- *  May open the channel
+ *	May open the channel
  *
  *----------------------------------------------------------------------
  */
@@ -1438,7 +1477,7 @@ TclWinOpenSerialChannel(handle, channelName, permissions)
     wsprintfA(channelName, "file%lx", (int) infoPtr);
 
     infoPtr->channel = Tcl_CreateChannel(&serialChannelType, channelName,
-            (ClientData) infoPtr, permissions);
+	    (ClientData) infoPtr, permissions);
 
     infoPtr->readable = 0; 
     infoPtr->writable = 1;
@@ -1450,30 +1489,31 @@ TclWinOpenSerialChannel(handle, channelName, permissions)
     infoPtr->sysBufRead = infoPtr->sysBufWrite = 4096;
 
     SetupComm(handle, infoPtr->sysBufRead, infoPtr->sysBufWrite);
-    PurgeComm(handle, PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR 
-            | PURGE_RXCLEAR);
+    PurgeComm(handle,
+	    PURGE_TXABORT | PURGE_RXABORT | PURGE_TXCLEAR | PURGE_RXCLEAR);
 
     /*
      * default is blocking
      */
-    SetCommTimeouts(handle, &no_timeout);
 
+    SetCommTimeouts(handle, &no_timeout);
 
     if (permissions & TCL_READABLE) {
-        infoPtr->osRead.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	infoPtr->osRead.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
     }
     if (permissions & TCL_WRITABLE) {
-        /* 
-        * Initially the channel is writable
-        * and the writeThread is idle.
-        */ 
-        infoPtr->osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-        infoPtr->evWritable = CreateEvent(NULL, TRUE, TRUE, NULL);
-        infoPtr->evStartWriter = CreateEvent(NULL, FALSE, FALSE, NULL);
+	/* 
+	 * Initially the channel is writable
+	 * and the writeThread is idle.
+	 */
+
+	infoPtr->osWrite.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	infoPtr->evWritable = CreateEvent(NULL, TRUE, TRUE, NULL);
+	infoPtr->evStartWriter = CreateEvent(NULL, FALSE, FALSE, NULL);
 	infoPtr->evStopWriter = CreateEvent(NULL, FALSE, FALSE, NULL);
-        InitializeCriticalSection(&infoPtr->csWrite);
-        infoPtr->writeThread = CreateThread(NULL, 256, SerialWriterThread,
-            infoPtr, 0, &id);
+	InitializeCriticalSection(&infoPtr->csWrite);
+	infoPtr->writeThread = CreateThread(NULL, 256, SerialWriterThread,
+		infoPtr, 0, &id);
     }
 
     /*
@@ -1486,61 +1526,77 @@ TclWinOpenSerialChannel(handle, channelName, permissions)
 
     return infoPtr->channel;
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialErrorStr --
  *
- *  Converts a Win32 serial error code to a list of readable errors
+ *	Converts a Win32 serial error code to a list of readable errors
+ *
+ * Results:
+ *	None.
+ *
+ * Side effects:
+ *	Generates readable errors in the supplied DString.
  *
  *----------------------------------------------------------------------
  */
+
 static void
 SerialErrorStr(error, dsPtr)
-    DWORD error;           /* Win32 serial error code */
-    Tcl_DString *dsPtr;    /* Where to store string */
+    DWORD error;		/* Win32 serial error code */
+    Tcl_DString *dsPtr;		/* Where to store string */
 {
-    if( (error & CE_RXOVER) != 0) {
-                Tcl_DStringAppendElement(dsPtr, "RXOVER");
+    if (error & CE_RXOVER) {
+	Tcl_DStringAppendElement(dsPtr, "RXOVER");
     }
-    if( (error & CE_OVERRUN) != 0) {
-                Tcl_DStringAppendElement(dsPtr, "OVERRUN");
+    if (error & CE_OVERRUN) {
+	Tcl_DStringAppendElement(dsPtr, "OVERRUN");
     }
-    if( (error & CE_RXPARITY) != 0) {
-                Tcl_DStringAppendElement(dsPtr, "RXPARITY");
+    if (error & CE_RXPARITY) {
+	Tcl_DStringAppendElement(dsPtr, "RXPARITY");
     }
-    if( (error & CE_FRAME) != 0) {
-                Tcl_DStringAppendElement(dsPtr, "FRAME");
+    if (error & CE_FRAME) {
+	Tcl_DStringAppendElement(dsPtr, "FRAME");
     }
-    if( (error & CE_BREAK) != 0) {
-                Tcl_DStringAppendElement(dsPtr, "BREAK");
+    if (error & CE_BREAK) {
+	Tcl_DStringAppendElement(dsPtr, "BREAK");
     }
-    if( (error & CE_TXFULL) != 0) {
-                Tcl_DStringAppendElement(dsPtr, "TXFULL");
+    if (error & CE_TXFULL) {
+	Tcl_DStringAppendElement(dsPtr, "TXFULL");
     }
-    if( (error & CE_PTO) != 0) {    /* PTO used to signal WRITE-TIMEOUT */
-                Tcl_DStringAppendElement(dsPtr, "TIMEOUT");
+    if (error & CE_PTO) {		/* PTO used to signal WRITE-TIMEOUT */
+	Tcl_DStringAppendElement(dsPtr, "TIMEOUT");
     }
-    if( (error & ~((DWORD) (SERIAL_READ_ERRORS | SERIAL_WRITE_ERRORS))) != 0) {
-                char buf[TCL_INTEGER_SPACE + 1];
-                wsprintfA(buf, "%d", error);
-                Tcl_DStringAppendElement(dsPtr, buf);
+    if (error & ~((DWORD) (SERIAL_READ_ERRORS | SERIAL_WRITE_ERRORS)))) {
+	char buf[TCL_INTEGER_SPACE + 1];
+
+	wsprintfA(buf, "%d", error);
+	Tcl_DStringAppendElement(dsPtr, buf);
     }
 }
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialModemStatusStr --
  *
- *  Converts a Win32 modem status list of readable flags
+ *	Converts a Win32 modem status list of readable flags
+ *
+ * Result:
+ *	None.
+ *
+ * Side effects:
+ *	Appends modem status flag strings to the given DString.
  *
  *----------------------------------------------------------------------
  */
+
 static void
 SerialModemStatusStr(status, dsPtr)
-    DWORD status;          /* Win32 modem status */
-    Tcl_DString *dsPtr;    /* Where to store string */
+    DWORD status;		/* Win32 modem status */
+    Tcl_DString *dsPtr;		/* Where to store string */
 {
     Tcl_DStringAppendElement(dsPtr, "CTS");
     Tcl_DStringAppendElement(dsPtr, (status & MS_CTS_ON)  ?  "1" : "0");
@@ -1551,29 +1607,30 @@ SerialModemStatusStr(status, dsPtr)
     Tcl_DStringAppendElement(dsPtr, "DCD");
     Tcl_DStringAppendElement(dsPtr, (status & MS_RLSD_ON)  ? "1" : "0");
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialSetOptionProc --
  *
- *  Sets an option on a channel.
+ *	Sets an option on a channel.
  *
  * Results:
- *  A standard Tcl result. Also sets the interp's result on error if
- *  interp is not NULL.
+ *	A standard Tcl result. Also sets the interp's result on error
+ *	if interp is not NULL.
  *
  * Side effects:
- *  May modify an option on a device.
+ *	May modify an option on a device.
  *
  *----------------------------------------------------------------------
  */
+
 static int
 SerialSetOptionProc(instanceData, interp, optionName, value)
-    ClientData instanceData;    /* File state. */
-    Tcl_Interp *interp;         /* For error reporting - can be NULL. */
-    CONST char *optionName;     /* Which option to set? */
-    CONST char *value;          /* New value for option. */
+    ClientData instanceData;	/* File state. */
+    Tcl_Interp *interp;		/* For error reporting - can be NULL. */
+    CONST char *optionName;	/* Which option to set? */
+    CONST char *value;		/* New value for option. */
 {
     SerialInfo *infoPtr;
     DCB dcb;
@@ -1583,527 +1640,521 @@ SerialSetOptionProc(instanceData, interp, optionName, value)
     CONST TCHAR *native;
     int argc;
     CONST char **argv;
-    
+
     infoPtr = (SerialInfo *) instanceData;
-    
+
     /* 
-    * Parse options
-    */
+     * Parse options.  This would be far easier if we had Tcl_Objs to
+     * work with as that would let us use Tcl_GetIndexFromObj()...
+     */
+
     len = strlen(optionName);
     vlen = strlen(value);
 
     /* 
-    * Option -mode baud,parity,databits,stopbits
-    */
+     * Option -mode baud,parity,databits,stopbits
+     */
+
     if ((len > 2) && (strncmp(optionName, "-mode", len) == 0)) {
-        
-        if (! GetCommState(infoPtr->handle, &dcb)) {
-            if (interp) {
-                Tcl_AppendResult(interp, 
-                    "can't get comm state", (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        native = Tcl_WinUtfToTChar(value, -1, &ds);
-        result = (*tclWinProcs->buildCommDCBProc)(native, &dcb);
-        Tcl_DStringFree(&ds);
-        
-        if (result == FALSE) {
-            if (interp) {
-                Tcl_AppendResult(interp,
-                    "bad value for -mode: should be baud,parity,data,stop",
-                    (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-
-        /* Default settings for serial communications */ 
-        dcb.fBinary = TRUE;
-        dcb.fErrorChar = FALSE;
-        dcb.fNull = FALSE;
-        dcb.fAbortOnError = FALSE;
-
-        if (! SetCommState(infoPtr->handle, &dcb) ) {
-            if (interp) {
-                Tcl_AppendResult(interp, 
-                    "can't set comm state", (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        return TCL_OK;
-    }
-    
+	if (!GetCommState(infoPtr->handle, &dcb)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "can't get comm state", (char *)NULL);
+	    }
+	    return TCL_ERROR;
+	}
+	native = Tcl_WinUtfToTChar(value, -1, &ds);
+	result = (*tclWinProcs->buildCommDCBProc)(native, &dcb);
+	Tcl_DStringFree(&ds);
+
+	if (result == FALSE) {
+	    if (interp) {
+		Tcl_AppendResult(interp,
+			"bad value for -mode: should be baud,parity,data,stop",
+			(char *) NULL);
+	    }
+	    return TCL_ERROR;
+	}
+
+	/* Default settings for serial communications */ 
+	dcb.fBinary = TRUE;
+	dcb.fErrorChar = FALSE;
+	dcb.fNull = FALSE;
+	dcb.fAbortOnError = FALSE;
+
+	if (!SetCommState(infoPtr->handle, &dcb)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "can't set comm state", (char *)NULL);
+	    }
+	    return TCL_ERROR;
+	}
+	return TCL_OK;
+    }
+
     /* 
-    * Option -handshake none|xonxoff|rtscts|dtrdsr
-    */
+     * Option -handshake none|xonxoff|rtscts|dtrdsr
+     */
+
     if ((len > 1) && (strncmp(optionName, "-handshake", len) == 0)) {
-        
-        if (! GetCommState(infoPtr->handle, &dcb)) {
-            if (interp) {
-                Tcl_AppendResult(interp, 
-                    "can't get comm state", (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        /* 
-        * Reset all handshake options
-        * DTR and RTS are ON by default
-        */
-        dcb.fOutX = dcb.fInX = FALSE;
-        dcb.fOutxCtsFlow = dcb.fOutxDsrFlow = dcb.fDsrSensitivity = FALSE;
-        dcb.fDtrControl = DTR_CONTROL_ENABLE;
-        dcb.fRtsControl = RTS_CONTROL_ENABLE;
-        dcb.fTXContinueOnXoff = FALSE;
-
-        /* 
-        * Adjust the handshake limits.
-        * Yes, the XonXoff limits seem to influence even hardware handshake
-        */
-        dcb.XonLim = (WORD) (infoPtr->sysBufRead*1/2);
-        dcb.XoffLim = (WORD) (infoPtr->sysBufRead*1/4);
-        
-        if (strnicmp(value, "NONE", vlen) == 0) {
-            /* leave all handshake options disabled */
-        } else if (strnicmp(value, "XONXOFF", vlen) == 0) {
-            dcb.fOutX = dcb.fInX = TRUE;
-        } else if (strnicmp(value, "RTSCTS", vlen) == 0) {
-            dcb.fOutxCtsFlow = TRUE;
-            dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
-        } else if (strnicmp(value, "DTRDSR", vlen) == 0) {
-            dcb.fOutxDsrFlow = TRUE;
-            dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;
-        } else {
-            if (interp) {
-                Tcl_AppendResult(interp, "bad value for -handshake: ",
-                    "must be one of xonxoff, rtscts, dtrdsr or none",
-                    (char *) NULL);
-                return TCL_ERROR;
-            }
-        }
-        
-        if (! SetCommState(infoPtr->handle, &dcb)) {
-            if (interp) {
-                Tcl_AppendResult(interp, 
-                    "can't set comm state", (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        return TCL_OK;
-    }
-    
+	if (!GetCommState(infoPtr->handle, &dcb)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "can't get comm state", (char *)NULL);
+	    }
+	    return TCL_ERROR;
+	}
+
+	/*
+	 * Reset all handshake options
+	 * DTR and RTS are ON by default
+	 */
+
+	dcb.fOutX = dcb.fInX = FALSE;
+	dcb.fOutxCtsFlow = dcb.fOutxDsrFlow = dcb.fDsrSensitivity = FALSE;
+	dcb.fDtrControl = DTR_CONTROL_ENABLE;
+	dcb.fRtsControl = RTS_CONTROL_ENABLE;
+	dcb.fTXContinueOnXoff = FALSE;
+
+	/*
+	 * Adjust the handshake limits.
+	 * Yes, the XonXoff limits seem to influence even hardware handshake
+	 */
+
+	dcb.XonLim = (WORD) (infoPtr->sysBufRead*1/2);
+	dcb.XoffLim = (WORD) (infoPtr->sysBufRead*1/4);
+
+	if (strnicmp(value, "NONE", vlen) == 0) {
+	    /* leave all handshake options disabled */
+	} else if (strnicmp(value, "XONXOFF", vlen) == 0) {
+	    dcb.fOutX = dcb.fInX = TRUE;
+	} else if (strnicmp(value, "RTSCTS", vlen) == 0) {
+	    dcb.fOutxCtsFlow = TRUE;
+	    dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
+	} else if (strnicmp(value, "DTRDSR", vlen) == 0) {
+	    dcb.fOutxDsrFlow = TRUE;
+	    dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;
+	} else {
+	    if (interp) {
+		Tcl_AppendResult(interp, "bad value for -handshake: ",
+			"must be one of xonxoff, rtscts, dtrdsr or none",
+			(char *) NULL);
+	    }
+	    return TCL_ERROR;
+	}
+
+	if (!SetCommState(infoPtr->handle, &dcb)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "can't set comm state", (char *)NULL);
+	    }
+	    return TCL_ERROR;
+	}
+	return TCL_OK;
+    }
+
     /* 
-    * Option -xchar {\x11 \x13}
-    */
+     * Option -xchar {\x11 \x13}
+     */
+
     if ((len > 1) && (strncmp(optionName, "-xchar", len) == 0)) {
-        
-        if (! GetCommState(infoPtr->handle, &dcb)) {
-            if (interp) {
-                Tcl_AppendResult(interp, 
-                    "can't get comm state", (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        
-        if (Tcl_SplitList(interp, value, &argc, &argv) == TCL_ERROR) {
-            return TCL_ERROR;
-        }
-        if (argc == 2) {
-            dcb.XonChar  = argv[0][0];
-            dcb.XoffChar = argv[1][0];
-        } else {
-            if (interp) {
-                Tcl_AppendResult(interp,
-                    "bad value for -xchar: should be a list of two elements",
-                    (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        
-        if (! SetCommState(infoPtr->handle, &dcb)) {
-            if (interp) {
-                Tcl_AppendResult(interp, 
-                    "can't set comm state", (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        return TCL_OK;
-    }
-    
+	if (!GetCommState(infoPtr->handle, &dcb)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "can't get comm state", (char *)NULL);
+	    }
+	    return TCL_ERROR;
+	}
+
+	if (Tcl_SplitList(interp, value, &argc, &argv) == TCL_ERROR) {
+	    return TCL_ERROR;
+	}
+	if (argc == 2) {
+	    dcb.XonChar  = argv[0][0];
+	    dcb.XoffChar = argv[1][0];
+	} else {
+	    if (interp) {
+		Tcl_AppendResult(interp,
+			"bad value for -xchar: should be a list of two elements",
+			(char *) NULL);
+	    }
+	    return TCL_ERROR;
+	}
+
+	if (!SetCommState(infoPtr->handle, &dcb)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "can't set comm state", (char *)NULL);
+	    }
+	    return TCL_ERROR;
+	}
+	return TCL_OK;
+    }
+
     /* 
-    * Option -ttycontrol {DTR 1 RTS 0 BREAK 0}
-    */
+     * Option -ttycontrol {DTR 1 RTS 0 BREAK 0}
+     */
+
     if ((len > 4) && (strncmp(optionName, "-ttycontrol", len) == 0)) {
-        
-        if (Tcl_SplitList(interp, value, &argc, &argv) == TCL_ERROR) {
-            return TCL_ERROR;
-        }
-        if ((argc % 2) == 1) {
-            if (interp) {
-                Tcl_AppendResult(interp,
-                    "bad value for -ttycontrol: should be a list of signal,value pairs",
-                    (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        while (argc > 1) {
-            if (Tcl_GetBoolean(interp, argv[1], &flag) == TCL_ERROR) {
-                return TCL_ERROR;
-            }
-            if (strnicmp(argv[0], "DTR", strlen(argv[0])) == 0) {
-                if (! EscapeCommFunction(infoPtr->handle, flag ?
-                        (DWORD) SETDTR : (DWORD) CLRDTR)) {
-                    if (interp) {
-                        Tcl_AppendResult(interp, 
-                            "can't set DTR signal", (char *) NULL);
-                    }
-                    return TCL_ERROR;
-                }
-            } else if (strnicmp(argv[0], "RTS", strlen(argv[0])) == 0) {
-                if (! EscapeCommFunction(infoPtr->handle, flag ?
-                        (DWORD) SETRTS : (DWORD) CLRRTS)) {
-                    if (interp) {
-                        Tcl_AppendResult(interp, 
-                            "can't set RTS signal", (char *) NULL);
-                    }
-                    return TCL_ERROR;
-                }
-            } else if (strnicmp(argv[0], "BREAK", strlen(argv[0])) == 0) {
-                if (! EscapeCommFunction(infoPtr->handle, flag ?
-                        (DWORD) SETBREAK : (DWORD) CLRBREAK)) {
-                    if (interp) {
-                        Tcl_AppendResult(interp, 
-                            "can't set BREAK signal", (char *) NULL);
-                    }
-                    return TCL_ERROR;
-                }
-            } else {
-                if (interp) {
-                    Tcl_AppendResult(interp, 
-                        "bad signal for -ttycontrol: must be DTR, RTS or BREAK", 
-                        (char *) NULL);
-                }
-                return TCL_ERROR;
-            }
-            argc -= 2, argv += 2;
-        } /* while (argc > 1) */
-        
-        return TCL_OK;
-    }
-    
+	if (Tcl_SplitList(interp, value, &argc, &argv) == TCL_ERROR) {
+	    return TCL_ERROR;
+	}
+	if ((argc % 2) == 1) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "bad value for -ttycontrol: ",
+			"should be a list of signal,value pairs",
+			(char *) NULL);
+	    }
+	    return TCL_ERROR;
+	}
+	while (argc > 1) {
+	    if (Tcl_GetBoolean(interp, argv[1], &flag) == TCL_ERROR) {
+		return TCL_ERROR;
+	    }
+	    if (strnicmp(argv[0], "DTR", strlen(argv[0])) == 0) {
+		if (!EscapeCommFunction(infoPtr->handle, flag ?
+			(DWORD) SETDTR : (DWORD) CLRDTR)) {
+		    if (interp) {
+			Tcl_AppendResult(interp, "can't set DTR signal",
+				(char *) NULL);
+		    }
+		    return TCL_ERROR;
+		}
+	    } else if (strnicmp(argv[0], "RTS", strlen(argv[0])) == 0) {
+		if (!EscapeCommFunction(infoPtr->handle, flag ?
+			(DWORD) SETRTS : (DWORD) CLRRTS)) {
+		    if (interp) {
+			Tcl_AppendResult(interp, "can't set RTS signal",
+				(char *) NULL);
+		    }
+		    return TCL_ERROR;
+		}
+	    } else if (strnicmp(argv[0], "BREAK", strlen(argv[0])) == 0) {
+		if (!EscapeCommFunction(infoPtr->handle, flag ?
+			(DWORD) SETBREAK : (DWORD) CLRBREAK)) {
+		    if (interp) {
+			Tcl_AppendResult(interp, "can't set BREAK signal",
+				(char *) NULL);
+		    }
+		    return TCL_ERROR;
+		}
+	    } else {
+		if (interp) {
+		    Tcl_AppendResult(interp, "bad signal for -ttycontrol: ",
+			    "must be DTR, RTS or BREAK", (char *) NULL);
+		}
+		return TCL_ERROR;
+	    }
+	    argc -= 2;
+	    argv += 2;
+	} /* while (argc > 1) */
+
+	return TCL_OK;
+    }
+
     /* 
-    * Option -sysbuffer {read_size write_size}
-    * Option -sysbuffer read_size 
-    */
+     * Option -sysbuffer {read_size write_size}
+     * Option -sysbuffer read_size 
+     */
+
     if ((len > 1) && (strncmp(optionName, "-sysbuffer", len) == 0)) {
-        
-        /*
-        * -sysbuffer 4096 or -sysbuffer {64536 4096}
-        */
-        size_t inSize = (size_t) -1, outSize = (size_t) -1;
-        
-        if (Tcl_SplitList(interp, value, &argc, &argv) == TCL_ERROR) {
-            return TCL_ERROR;
-        }
-        if (argc == 1) {
-            inSize = atoi(argv[0]);
-            outSize = infoPtr->sysBufWrite;
-        } else if (argc == 2) {
-            inSize  = atoi(argv[0]);
-            outSize = atoi(argv[1]);
-        }
-        if ( (inSize <= 0) || (outSize <= 0) ) {
-            if (interp) {
-                Tcl_AppendResult(interp,
-                    "bad value for -sysbuffer: should be a list of one or two integers > 0",
-                    (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        if (! SetupComm(infoPtr->handle, inSize, outSize)) {
-            if (interp) {
-                Tcl_AppendResult(interp, 
-                    "can't setup comm buffers", (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        infoPtr->sysBufRead  = inSize;
-        infoPtr->sysBufWrite = outSize;
-        
-         /* 
-        * Adjust the handshake limits.
-        * Yes, the XonXoff limits seem to influence even hardware handshake
-        */
-        if (! GetCommState(infoPtr->handle, &dcb)) {
-            if (interp) {
-                Tcl_AppendResult(interp, 
-                    "can't get comm state", (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        dcb.XonLim = (WORD) (infoPtr->sysBufRead*1/2);
-        dcb.XoffLim = (WORD) (infoPtr->sysBufRead*1/4);
-        if (! SetCommState(infoPtr->handle, &dcb)) {
-            if (interp) {
-                Tcl_AppendResult(interp, 
-                    "can't set comm state", (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        return TCL_OK;
+	/*
+	 * -sysbuffer 4096 or -sysbuffer {64536 4096}
+	 */
+	size_t inSize = (size_t) -1, outSize = (size_t) -1;
+
+	if (Tcl_SplitList(interp, value, &argc, &argv) == TCL_ERROR) {
+	    return TCL_ERROR;
+	}
+	if (argc == 1) {
+	    inSize = atoi(argv[0]);
+	    outSize = infoPtr->sysBufWrite;
+	} else if (argc == 2) {
+	    inSize  = atoi(argv[0]);
+	    outSize = atoi(argv[1]);
+	}
+	if ((inSize <= 0) || (outSize <= 0)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "bad value for -sysbuffer: ",
+			"should be a list of one or two integers > 0",
+			(char *) NULL);
+	    }
+	    return TCL_ERROR;
+	}
+	if (!SetupComm(infoPtr->handle, inSize, outSize)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "can't setup comm buffers",
+			(char *) NULL);
+	    }
+	    return TCL_ERROR;
+	}
+	infoPtr->sysBufRead  = inSize;
+	infoPtr->sysBufWrite = outSize;
+
+	/* 
+	 * Adjust the handshake limits.  Yes, the XonXoff limits seem
+	 * to influence even hardware handshake
+	 */
+
+	if (!GetCommState(infoPtr->handle, &dcb)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "can't get comm state",
+			(char *) NULL);
+	    }
+	    return TCL_ERROR;
+	}
+	dcb.XonLim = (WORD) (infoPtr->sysBufRead*1/2);
+	dcb.XoffLim = (WORD) (infoPtr->sysBufRead*1/4);
+	if (!SetCommState(infoPtr->handle, &dcb)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "can't set comm state",
+			(char *) NULL);
+	    }
+	    return TCL_ERROR;
+	}
+	return TCL_OK;
     }
 
     /* 
-    * Option -pollinterval msec
-    */
+     * Option -pollinterval msec
+     */
+
     if ((len > 1) && (strncmp(optionName, "-pollinterval", len) == 0)) {
-        
-        if ( Tcl_GetInt(interp, value, &(infoPtr->blockTime)) != TCL_OK ) {
-            return TCL_ERROR;
-        }
-        return TCL_OK;
+	if (Tcl_GetInt(interp, value, &(infoPtr->blockTime)) != TCL_OK ) {
+	    return TCL_ERROR;
+	}
+	return TCL_OK;
     }
-    
-    /* 
-    * Option -timeout msec
-    */
+
+    /*
+     * Option -timeout msec
+     */
+
     if ((len > 2) && (strncmp(optionName, "-timeout", len) == 0)) {
-        int msec;
-        COMMTIMEOUTS tout = {0,0,0,0,0};
-  
-        if ( Tcl_GetInt(interp, value, &msec) != TCL_OK ) {
-            return TCL_ERROR;
-        }
-        tout.ReadTotalTimeoutConstant = msec;
-        if (! SetCommTimeouts(infoPtr->handle, &tout)) {
-            if (interp) {
-                Tcl_AppendResult(interp, 
-                    "can't set comm timeouts", (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-
-        return TCL_OK;
-    }
-    
+	int msec;
+	COMMTIMEOUTS tout = {0,0,0,0,0};
+
+	if (Tcl_GetInt(interp, value, &msec) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	tout.ReadTotalTimeoutConstant = msec;
+	if (!SetCommTimeouts(infoPtr->handle, &tout)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "can't set comm timeouts",
+			(char *) NULL);
+	    }
+	    return TCL_ERROR;
+	}
+
+	return TCL_OK;
+    }
+
     return Tcl_BadChannelOption(interp, optionName,
-        "mode handshake pollinterval sysbuffer timeout ttycontrol xchar");
+	"mode handshake pollinterval sysbuffer timeout ttycontrol xchar");
 }
-
+
 /*
  *----------------------------------------------------------------------
  *
  * SerialGetOptionProc --
  *
- *  Gets a mode associated with an IO channel. If the optionName arg
- *  is non NULL, retrieves the value of that option. If the optionName
- *  arg is NULL, retrieves a list of alternating option names and
- *  values for the given channel.
+ *	Gets a mode associated with an IO channel. If the optionName
+ *	arg is non NULL, retrieves the value of that option. If the
+ *	optionName arg is NULL, retrieves a list of alternating option
+ *	names and values for the given channel.
  *
  * Results:
- *  A standard Tcl result. Also sets the supplied DString to the
- *  string value of the option(s) returned.
+ *	A standard Tcl result. Also sets the supplied DString to the
+ *	string value of the option(s) returned.
  *
  * Side effects:
- *  The string returned by this function is in static storage and
- *  may be reused at any time subsequent to the call.
+ *	The string returned by this function is in static storage and
+ *	may be reused at any time subsequent to the call.
  *
  *----------------------------------------------------------------------
  */
+
 static int
 SerialGetOptionProc(instanceData, interp, optionName, dsPtr)
-    ClientData instanceData;    /* File state. */
-    Tcl_Interp *interp;         /* For error reporting - can be NULL. */
-    CONST char *optionName;     /* Option to get. */
-    Tcl_DString *dsPtr;         /* Where to store value(s). */
+    ClientData instanceData;	/* File state. */
+    Tcl_Interp *interp;		/* For error reporting - can be NULL. */
+    CONST char *optionName;	/* Option to get. */
+    Tcl_DString *dsPtr;		/* Where to store value(s). */
 {
     SerialInfo *infoPtr;
     DCB dcb;
     size_t len;
     int valid = 0;  /* flag if valid option parsed */
-    
+
     infoPtr = (SerialInfo *) instanceData;
-    
+
     if (optionName == NULL) {
-        len = 0;
+	len = 0;
     } else {
-        len = strlen(optionName);
+	len = strlen(optionName);
     }
-    
+
     /*
-    * get option -mode
-    */
-    
+     * get option -mode
+     */
+
     if (len == 0) {
-        Tcl_DStringAppendElement(dsPtr, "-mode");
-    }
-    if ((len == 0) ||
-        ((len > 2) && (strncmp(optionName, "-mode", len) == 0))) {
-        
-        char parity;
-        char *stop;
-        char buf[2 * TCL_INTEGER_SPACE + 16];
-        
-        if (! GetCommState(infoPtr->handle, &dcb)) {
-            if (interp) {
-                Tcl_AppendResult(interp, 
-                    "can't get comm state", (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        
-        valid = 1;
-        parity = 'n';
-        if (dcb.Parity <= 4) {
-            parity = "noems"[dcb.Parity];
-        }
-        stop = (dcb.StopBits == ONESTOPBIT) ? "1" :
-        (dcb.StopBits == ONE5STOPBITS) ? "1.5" : "2";
-        
-        wsprintfA(buf, "%d,%c,%d,%s", dcb.BaudRate, parity,
-            dcb.ByteSize, stop);
-        Tcl_DStringAppendElement(dsPtr, buf);
-    }
-    
+	Tcl_DStringAppendElement(dsPtr, "-mode");
+    }
+    if (len==0 || (len>2 && (strncmp(optionName, "-mode", len) == 0))) {
+	char parity;
+	char *stop;
+	char buf[2 * TCL_INTEGER_SPACE + 16];
+
+	if (!GetCommState(infoPtr->handle, &dcb)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "can't get comm state", (char *)NULL);
+	    }
+	    return TCL_ERROR;
+	}
+
+	valid = 1;
+	parity = 'n';
+	if (dcb.Parity <= 4) {
+	    parity = "noems"[dcb.Parity];
+	}
+	stop = (dcb.StopBits == ONESTOPBIT) ? "1" :
+		(dcb.StopBits == ONE5STOPBITS) ? "1.5" : "2";
+
+	wsprintfA(buf, "%d,%c,%d,%s", dcb.BaudRate, parity,
+		dcb.ByteSize, stop);
+	Tcl_DStringAppendElement(dsPtr, buf);
+    }
+
     /*
-    * get option -pollinterval
-    */
-    
+     * get option -pollinterval
+     */
+
     if (len == 0) {
-        Tcl_DStringAppendElement(dsPtr, "-pollinterval");
+	Tcl_DStringAppendElement(dsPtr, "-pollinterval");
     }
-    if ((len == 0) ||
-        ((len > 1) && (strncmp(optionName, "-pollinterval", len) == 0))) {
-        char buf[TCL_INTEGER_SPACE + 1];
-        
-        valid = 1;
-        wsprintfA(buf, "%d", infoPtr->blockTime);
-        Tcl_DStringAppendElement(dsPtr, buf);
+    if (len==0 || (len>1 && strncmp(optionName, "-pollinterval", len)==0)) {
+	char buf[TCL_INTEGER_SPACE + 1];
+
+	valid = 1;
+	wsprintfA(buf, "%d", infoPtr->blockTime);
+	Tcl_DStringAppendElement(dsPtr, buf);
     }
-    
+
     /*
-    * get option -sysbuffer
-    */
-    
+     * get option -sysbuffer
+     */
+
     if (len == 0) {
-        Tcl_DStringAppendElement(dsPtr, "-sysbuffer");
-        Tcl_DStringStartSublist(dsPtr);
+	Tcl_DStringAppendElement(dsPtr, "-sysbuffer");
+	Tcl_DStringStartSublist(dsPtr);
     }
-    if ((len == 0) ||
-        ((len > 1) && (strncmp(optionName, "-sysbuffer", len) == 0))) {
+    if (len==0 || (len>1 && strncmp(optionName, "-sysbuffer", len) == 0)) {
+	char buf[TCL_INTEGER_SPACE + 1];
+	valid = 1;
 
-        char buf[TCL_INTEGER_SPACE + 1];
-        valid = 1;
-
-        wsprintfA(buf, "%d", infoPtr->sysBufRead);
-        Tcl_DStringAppendElement(dsPtr, buf);
-        wsprintfA(buf, "%d", infoPtr->sysBufWrite);
-        Tcl_DStringAppendElement(dsPtr, buf);
+	wsprintfA(buf, "%d", infoPtr->sysBufRead);
+	Tcl_DStringAppendElement(dsPtr, buf);
+	wsprintfA(buf, "%d", infoPtr->sysBufWrite);
+	Tcl_DStringAppendElement(dsPtr, buf);
     }
     if (len == 0) {
-        Tcl_DStringEndSublist(dsPtr);
+	Tcl_DStringEndSublist(dsPtr);
     }
-    
+
     /*
-    * get option -xchar
-    */
-    
+     * get option -xchar
+     */
+
     if (len == 0) {
-        Tcl_DStringAppendElement(dsPtr, "-xchar");
-        Tcl_DStringStartSublist(dsPtr);
-    }
-    if ((len == 0) ||
-        ((len > 1) && (strncmp(optionName, "-xchar", len) == 0))) {
-
-        char buf[4];
-        valid = 1;
-
-        if (! GetCommState(infoPtr->handle, &dcb)) {
-            if (interp) {
-                Tcl_AppendResult(interp, 
-                    "can't get comm state", (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        sprintf(buf, "%c", dcb.XonChar);
-        Tcl_DStringAppendElement(dsPtr, buf);
-        sprintf(buf, "%c", dcb.XoffChar);
-        Tcl_DStringAppendElement(dsPtr, buf);
+	Tcl_DStringAppendElement(dsPtr, "-xchar");
+	Tcl_DStringStartSublist(dsPtr);
+    }
+    if (len==0 || (len>1 && strncmp(optionName, "-xchar", len) == 0)) {
+	char buf[4];
+	valid = 1;
+
+	if (!GetCommState(infoPtr->handle, &dcb)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "can't get comm state", (char *)NULL);
+	    }
+	    return TCL_ERROR;
+	}
+	sprintf(buf, "%c", dcb.XonChar);
+	Tcl_DStringAppendElement(dsPtr, buf);
+	sprintf(buf, "%c", dcb.XoffChar);
+	Tcl_DStringAppendElement(dsPtr, buf);
     }
     if (len == 0) {
-        Tcl_DStringEndSublist(dsPtr);
+	Tcl_DStringEndSublist(dsPtr);
     }
 
     /*
-    * get option -lasterror
-    * option is readonly and returned by [fconfigure chan -lasterror]
-    * but not returned by unnamed [fconfigure chan]
-    */
-    
-    if ( (len > 1) && (strncmp(optionName, "-lasterror", len) == 0) ) {
-        valid = 1;
-        SerialErrorStr(infoPtr->lastError, dsPtr);
-    }
-    
+     * get option -lasterror
+     * option is readonly and returned by [fconfigure chan -lasterror]
+     * but not returned by unnamed [fconfigure chan]
+     */
+
+    if (len>1 && strncmp(optionName, "-lasterror", len)==0) {
+	valid = 1;
+	SerialErrorStr(infoPtr->lastError, dsPtr);
+    }
+
     /*
-    * get option -queue
-    * option is readonly and returned by [fconfigure chan -queue]
-    */
-    
-    if ((len > 1) && (strncmp(optionName, "-queue", len) == 0)) {
-        char buf[TCL_INTEGER_SPACE + 1];
-        COMSTAT cStat;
-        DWORD error;
+     * get option -queue
+     * option is readonly and returned by [fconfigure chan -queue]
+     */
+
+    if (len>1 && strncmp(optionName, "-queue", len)==0) {
+	char buf[TCL_INTEGER_SPACE + 1];
+	COMSTAT cStat;
+	DWORD error;
 	int inBuffered, outBuffered, count;
 
-        valid = 1;
+	valid = 1;
+
+	/*
+	 * Query the pending data in Tcl's internal queues
+	 */
 
-        /* 
-        * Query the pending data in Tcl's internal queues
-        */
-        inBuffered  = Tcl_InputBuffered(infoPtr->channel);
+	inBuffered  = Tcl_InputBuffered(infoPtr->channel);
 	outBuffered = Tcl_OutputBuffered(infoPtr->channel);
 
-        /*
-        * Query the number of bytes in our output queue:
-        *     1. The bytes pending in the output thread
-        *     2. The bytes in the system drivers buffer
-        * The writer thread should not interfere this action.
-        */
-        EnterCriticalSection(&infoPtr->csWrite);
-        ClearCommError( infoPtr->handle, &error, &cStat );
-        count = (int)cStat.cbOutQue + infoPtr->writeQueue;
-        LeaveCriticalSection(&infoPtr->csWrite);
+	/*
+	 * Query the number of bytes in our output queue:
+	 *     1. The bytes pending in the output thread
+	 *     2. The bytes in the system drivers buffer
+	 * The writer thread should not interfere this action.
+	 */
+
+	EnterCriticalSection(&infoPtr->csWrite);
+	ClearCommError( infoPtr->handle, &error, &cStat );
+	count = (int)cStat.cbOutQue + infoPtr->writeQueue;
+	LeaveCriticalSection(&infoPtr->csWrite);
 
-        wsprintfA(buf, "%d", inBuffered + cStat.cbInQue); 
-        Tcl_DStringAppendElement(dsPtr, buf);
-        wsprintfA(buf, "%d", outBuffered + count); 
-        Tcl_DStringAppendElement(dsPtr, buf);
+	wsprintfA(buf, "%d", inBuffered + cStat.cbInQue); 
+	Tcl_DStringAppendElement(dsPtr, buf);
+	wsprintfA(buf, "%d", outBuffered + count); 
+	Tcl_DStringAppendElement(dsPtr, buf);
     }
 
     /*
-    * get option -ttystatus
-    * option is readonly and returned by [fconfigure chan -ttystatus]
-    * but not returned by unnamed [fconfigure chan]
-    */
-    if ( (len > 4) && (strncmp(optionName, "-ttystatus", len) == 0) ) {
-        
-        DWORD status;
-        
-        if (! GetCommModemStatus(infoPtr->handle, &status)) {
-            if (interp) {
-                Tcl_AppendResult(interp, 
-                    "can't get tty status", (char *) NULL);
-            }
-            return TCL_ERROR;
-        }
-        valid = 1;
-        SerialModemStatusStr(status, dsPtr);
-    }
-    
+     * get option -ttystatus
+     * option is readonly and returned by [fconfigure chan -ttystatus]
+     * but not returned by unnamed [fconfigure chan]
+     */
+
+    if (len>4 && strncmp(optionName, "-ttystatus", len)==0) {
+	DWORD status;
+
+	if (!GetCommModemStatus(infoPtr->handle, &status)) {
+	    if (interp) {
+		Tcl_AppendResult(interp, "can't get tty status", (char *)NULL);
+	    }
+	    return TCL_ERROR;
+	}
+	valid = 1;
+	SerialModemStatusStr(status, dsPtr);
+    }
+
     if (valid) {
-        return TCL_OK;
+	return TCL_OK;
     } else {
-        return Tcl_BadChannelOption(interp, optionName,
-            "mode pollinterval lasterror queue sysbuffer ttystatus xchar");
+	return Tcl_BadChannelOption(interp, optionName,
+		"mode pollinterval lasterror queue sysbuffer ttystatus xchar");
     }
 }