diff options
Diffstat (limited to 'win')
| -rw-r--r-- | win/tclWinSerial.c | 2237 |
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"); } } |